| /* |
| * 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. |
| */ |
| |
| package org.apache.uima.collection.impl.cpm.container; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InvalidObjectException; |
| import java.net.URL; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Vector; |
| |
| import javax.naming.ConfigurationException; |
| |
| import org.apache.uima.UIMAFramework; |
| import org.apache.uima.UIMARuntimeException; |
| import org.apache.uima.UimaContextAdmin; |
| import org.apache.uima.analysis_engine.AnalysisEngineDescription; |
| import org.apache.uima.cas.CAS; |
| import org.apache.uima.collection.CasConsumer; |
| import org.apache.uima.collection.CasConsumerDescription; |
| import org.apache.uima.collection.CasInitializer; |
| import org.apache.uima.collection.CasInitializerDescription; |
| import org.apache.uima.collection.CollectionReader; |
| import org.apache.uima.collection.base_cpm.BaseCollectionReader; |
| import org.apache.uima.collection.base_cpm.CasDataCollectionReader; |
| import org.apache.uima.collection.base_cpm.CasDataConsumer; |
| import org.apache.uima.collection.base_cpm.CasDataInitializer; |
| import org.apache.uima.collection.base_cpm.CasProcessor; |
| import org.apache.uima.collection.impl.cpm.CPMException; |
| import org.apache.uima.collection.impl.cpm.Constants; |
| import org.apache.uima.collection.impl.cpm.container.deployer.DeployFactory; |
| import org.apache.uima.collection.impl.cpm.utils.CPMUtils; |
| import org.apache.uima.collection.impl.cpm.utils.CpmLocalizedMessage; |
| import org.apache.uima.collection.impl.metadata.cpe.CpeDescriptionImpl; |
| import org.apache.uima.collection.impl.metadata.cpe.CpeDescriptorFactory; |
| import org.apache.uima.collection.impl.metadata.cpe.CpeIntegratedCasProcessorImpl; |
| import org.apache.uima.collection.metadata.CasProcessorConfigurationParameterSettings; |
| import org.apache.uima.collection.metadata.CasProcessorDeploymentParam; |
| import org.apache.uima.collection.metadata.CasProcessorDeploymentParams; |
| import org.apache.uima.collection.metadata.CpeCasProcessor; |
| import org.apache.uima.collection.metadata.CpeCasProcessors; |
| import org.apache.uima.collection.metadata.CpeCollectionReader; |
| import org.apache.uima.collection.metadata.CpeCollectionReaderCasInitializer; |
| import org.apache.uima.collection.metadata.CpeCollectionReaderIterator; |
| import org.apache.uima.collection.metadata.CpeConfiguration; |
| import org.apache.uima.collection.metadata.CpeDescription; |
| import org.apache.uima.collection.metadata.CpeDescriptorException; |
| import org.apache.uima.collection.metadata.CpeResourceManagerConfiguration; |
| import org.apache.uima.collection.metadata.CpeSofaMapping; |
| import org.apache.uima.collection.metadata.CpeSofaMappings; |
| import org.apache.uima.resource.ConfigurableResource_ImplBase; |
| import org.apache.uima.resource.Resource; |
| import org.apache.uima.resource.ResourceConfigurationException; |
| import org.apache.uima.resource.ResourceCreationSpecifier; |
| import org.apache.uima.resource.ResourceInitializationException; |
| import org.apache.uima.resource.ResourceManager; |
| import org.apache.uima.resource.ResourceSpecifier; |
| import org.apache.uima.resource.metadata.ConfigurationParameter; |
| import org.apache.uima.resource.metadata.ConfigurationParameterDeclarations; |
| import org.apache.uima.resource.metadata.ConfigurationParameterSettings; |
| import org.apache.uima.resource.metadata.NameValuePair; |
| import org.apache.uima.resource.metadata.ResourceManagerConfiguration; |
| import org.apache.uima.resource.metadata.impl.NameValuePair_impl; |
| import org.apache.uima.util.InvalidXMLException; |
| import org.apache.uima.util.Level; |
| import org.apache.uima.util.XMLInputSource; |
| |
| /** |
| * Component responsible for generating objects representing cpe descriptor configuration. Provides |
| * various ways to instantiate object model representing cpe configuration. In the simplest form it |
| * ingests an xml file (cpe descriptor), parses it and creates an object for every element in the |
| * xml file. |
| * <p> |
| * Using objects representing configuration, this component creates CollectionReader CasInitializer, |
| * Analysis Engines, and Cas Consumers. |
| * <p> |
| * In addition to creating object, this component provides read/write access to the object model |
| * allowing for dynamic or programmatic modifications. It facilitates plugging in existing |
| * CollectionReaders and CasProcessors. |
| * |
| * |
| */ |
| public class CPEFactory { |
| public static final String CPM_HOME = "${CPM_HOME}"; |
| |
| private int processorCount = 0; |
| |
| private String DEFAULT_CONFIG_FILE = "defaultCpeDescriptor.xml"; |
| |
| private boolean defaultConfig = true; |
| |
| public HashMap casProcessorConfigMap = new HashMap(); |
| |
| private CpeDescription cpeDescriptor = null; |
| |
| private boolean initialized = false; |
| |
| private UimaContextAdmin uimaContext; |
| |
| private boolean firstTime = true; |
| |
| private HashMap cpMap = new HashMap(); |
| |
| /** |
| * Create a new CPEFactory on which we will later call parse(String) to parse a CPE descriptor. |
| */ |
| public CPEFactory(ResourceManager aResourceManager) { |
| if (aResourceManager == null) { |
| aResourceManager = UIMAFramework.newDefaultResourceManager(); |
| } |
| uimaContext = UIMAFramework.newUimaContext(UIMAFramework.getLogger(), aResourceManager, |
| UIMAFramework.newConfigurationManager()); |
| } |
| |
| /** |
| * Create a new CPEFactory for a CpeDescription that's already been parsed. |
| * |
| * @param aDescriptor |
| * @param aResourceManager |
| * the resource manager that all components of this CPE will share If null, a new |
| * ResourceManager will be created. |
| */ |
| public CPEFactory(CpeDescription aDescriptor, ResourceManager aResourceManager) |
| throws ResourceInitializationException { |
| if (aDescriptor == null) { |
| throw new UIMARuntimeException(new InvalidObjectException(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_no_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| |
| if (aResourceManager == null) { |
| aResourceManager = UIMAFramework.newDefaultResourceManager(); |
| } |
| setCpeDescriptor(aDescriptor); |
| if (aDescriptor != null && aDescriptor instanceof CpeDescriptionImpl) { |
| defaultConfig = false; |
| } |
| |
| uimaContext = UIMAFramework.newUimaContext(UIMAFramework.getLogger(), aResourceManager, |
| UIMAFramework.newConfigurationManager()); |
| // if CpeDescription contains a ResourceManagerConfiguration, parse it and use it |
| // to configure the ResourceManager |
| CpeResourceManagerConfiguration resMgrCfgDesc = aDescriptor.getResourceManagerConfiguration(); |
| if (resMgrCfgDesc != null) { |
| ResourceManagerConfiguration resMgrCfg; |
| try { |
| if (resMgrCfgDesc.get().length() > 0) { |
| String descriptorPath = CPMUtils.convertToAbsolutePath(System.getProperty("CPM_HOME"), |
| CPM_HOME, resMgrCfgDesc.get()); |
| resMgrCfg = UIMAFramework.getXMLParser().parseResourceManagerConfiguration( |
| new XMLInputSource(descriptorPath)); |
| aResourceManager.initializeExternalResources(resMgrCfg, "/", null); |
| } |
| } catch (InvalidXMLException e) { |
| throw new ResourceInitializationException(e); |
| } catch (IOException e) { |
| throw new ResourceInitializationException(e); |
| } |
| } |
| } |
| |
| /** |
| * Creates an object representation for configuration in a given cpe descriptor file. |
| * |
| * @param aDescriptor - |
| * path to the descriptor |
| * |
| * @throws InstantiationException |
| */ |
| public void parse(String aDescriptor) throws InstantiationException { |
| defaultConfig = false; |
| |
| if (aDescriptor == null || aDescriptor.trim().length() == 0) { |
| throw new UIMARuntimeException(new FileNotFoundException(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_no_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| |
| try { |
| setCpeDescriptor(CpeDescriptorFactory.produceDescriptor(new FileInputStream(new File( |
| aDescriptor)))); |
| |
| } catch (Exception e) { |
| throw new UIMARuntimeException(InvalidXMLException.INVALID_DESCRIPTOR_FILE, |
| new Object[] { aDescriptor }, e); |
| } |
| } |
| |
| /** |
| * Creates an object representation for configuration in a given stream |
| * |
| * @param aDescriptorStream - |
| * stream containing cpe description |
| * @throws InstantiationException |
| */ |
| public void parse(InputStream aDescriptorStream) throws InstantiationException { |
| defaultConfig = false; |
| |
| if (aDescriptorStream == null) { |
| throw new UIMARuntimeException(new IOException(CpmLocalizedMessage.getLocalizedMessage( |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_invalid_cpe_descriptor_stream__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| |
| try { |
| setCpeDescriptor(CpeDescriptorFactory.produceDescriptor(aDescriptorStream)); |
| } catch (Exception e) { |
| throw new UIMARuntimeException(e); |
| } |
| } |
| |
| /** |
| * Creates an object representation from default cpe descriptor. |
| * |
| * @param aDescriptorStream - |
| * stream containing cpe description |
| * @throws InstantiationException |
| */ |
| |
| public void parse() { |
| defaultConfig = true; |
| InputStream defaultDescriptorStream = getClass().getResourceAsStream(DEFAULT_CONFIG_FILE); |
| try { |
| setCpeDescriptor(CpeDescriptorFactory.produceDescriptor(defaultDescriptorStream)); |
| } catch (Exception e) { |
| throw new UIMARuntimeException(e); |
| } finally { |
| try { |
| defaultDescriptorStream.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| } |
| |
| /** |
| * Checks if cpe description has been created |
| * |
| * @throws ConfigurationException |
| */ |
| private void checkForErrors() throws ResourceConfigurationException { |
| if (cpeDescriptor == null) { |
| throw new ResourceConfigurationException(new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_no_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| } |
| |
| /** |
| * Returns Collection Reader instantiated from configuration in the cpe descriptor. It also |
| * creates and intializes the Cas Initializer if one is defined and associates it with the |
| * CollectionReader. |
| * |
| * @return - CollectionReader instance |
| * |
| * @throws ConfigurationException |
| */ |
| public BaseCollectionReader getCollectionReader() throws ResourceConfigurationException { |
| checkForErrors(); |
| BaseCollectionReader colreader = null; |
| try { |
| CpeCollectionReader reader = (getCpeDescriptor().getAllCollectionCollectionReaders())[0]; |
| if (reader == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<collectionReader>", "<cpeDescriptor>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_required_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), "<collectionReader>" }))); |
| } |
| |
| CpeCollectionReaderIterator cit = reader.getCollectionIterator(); |
| if (cit == null || cit.getDescriptor() == null || |
| (cit.getDescriptor().getInclude() == null && cit.getDescriptor().getImport() == null)) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<include>", "<collectionIterator>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_required_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), "<include> or <import>" }))); |
| } |
| if (cit.getDescriptor().getInclude() != null && cit.getDescriptor().getInclude().get() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<href>", "<collectionIterator>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_attribute_from_xml_element__WARNING", |
| new Object[] { Thread.currentThread().getName(), "<href>", |
| "<collectionIterator>" }))); |
| } |
| |
| URL descriptorUrl = cit.getDescriptor().findAbsoluteUrl(getResourceManager()); |
| // create new collection reader from the descriptor |
| XMLInputSource in1 = new XMLInputSource(descriptorUrl); |
| ResourceSpecifier colReaderSp = UIMAFramework.getXMLParser() |
| .parseCollectionReaderDescription(in1); |
| |
| overrideParameterSettings(colReaderSp, cit.getConfigurationParameterSettings(), "Collection Reader"); |
| |
| // compute sofa mapping for the CollectionReader |
| CpeSofaMappings sofanamemappings = cit.getSofaNameMappings(); |
| HashMap sofamap = new HashMap(); |
| if (sofanamemappings != null) { |
| CpeSofaMapping[] sofaNameMappingArray = sofanamemappings.getSofaNameMappings(); |
| for (int i = 0; sofaNameMappingArray != null && i < sofaNameMappingArray.length; i++) { |
| CpeSofaMapping aSofaMap = sofaNameMappingArray[i]; |
| // if no component sofa name, then set it to default |
| if (aSofaMap.getComponentSofaName() == null) |
| aSofaMap.setComponentSofaName(CAS.NAME_DEFAULT_TEXT_SOFA); |
| sofamap.put(aSofaMap.getComponentSofaName(), aSofaMap.getCpeSofaName()); |
| } |
| } |
| |
| // create child UimaContext for the CollectionReader |
| UimaContextAdmin collectionReaderContext = uimaContext.createChild("_CollectionReader", |
| sofamap); |
| Map additionalParams = new HashMap(); |
| additionalParams.put(Resource.PARAM_UIMA_CONTEXT, collectionReaderContext); |
| colreader = (BaseCollectionReader) UIMAFramework.produceResource(BaseCollectionReader.class, |
| colReaderSp, getResourceManager(), additionalParams); |
| |
| //set up CAS Initializer |
| CpeCollectionReaderCasInitializer casInit = reader.getCasInitializer(); |
| if (casInit != null) { |
| if (casInit.getDescriptor() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<descriptor>", "<casInitializer>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_required_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), "<descriptor>" }))); |
| } |
| if (casInit.getDescriptor().getInclude() == null && casInit.getDescriptor().getImport() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<include>", "<casInitializer>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_required_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), "<include> or <import>" }))); |
| } |
| if (casInit.getDescriptor().getInclude() != null && |
| (casInit.getDescriptor().getInclude().get() == null |
| || casInit.getDescriptor().getInclude().get().length() == 0)) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<href>", "<casInitializer>" }, new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_attribute_from_xml_element__WARNING", |
| new Object[] { Thread.currentThread().getName(), "<href>", |
| "<casInitializer>" }))); |
| } |
| |
| URL casInitDescUrl = casInit.getDescriptor().findAbsoluteUrl(getResourceManager()); |
| |
| XMLInputSource in4 = new XMLInputSource(casInitDescUrl); |
| ResourceSpecifier casIniSp = UIMAFramework.getXMLParser().parseCasInitializerDescription( |
| in4); |
| |
| overrideParameterSettings(casIniSp, casInit.getConfigurationParameterSettings(), |
| "Cas Initializer"); |
| |
| // compute sofa mapping for the CAS Initializer |
| CpeSofaMappings sofaNamemappings = casInit.getSofaNameMappings(); |
| sofamap = new HashMap(); |
| if (sofaNamemappings != null) { |
| CpeSofaMapping[] sofaNameMappingArray = sofaNamemappings.getSofaNameMappings(); |
| for (int i = 0; sofaNameMappingArray != null && i < sofaNameMappingArray.length; i++) { |
| CpeSofaMapping aSofaMap = sofaNameMappingArray[i]; |
| // if no component sofa name, then set it to default |
| if (aSofaMap.getComponentSofaName() == null) |
| aSofaMap.setComponentSofaName(CAS.NAME_DEFAULT_TEXT_SOFA); |
| sofamap.put(aSofaMap.getComponentSofaName(), aSofaMap.getCpeSofaName()); |
| } |
| } |
| |
| // create child UimaContext for the CAS Initializer |
| UimaContextAdmin initializerContext = uimaContext.createChild("_CasInitializer", sofamap); |
| additionalParams.put(Resource.PARAM_UIMA_CONTEXT, initializerContext); |
| |
| Object initializer = produceInitializer(casIniSp, additionalParams); |
| |
| if (initializer instanceof CasDataInitializer) { |
| ((CasDataCollectionReader) colreader).setCasInitializer((CasDataInitializer) initializer); |
| } else if (initializer instanceof CasInitializer) { |
| ((CollectionReader) colreader).setCasInitializer((CasInitializer) initializer); |
| } else { |
| throw new ResourceConfigurationException(InvalidXMLException.INVALID_ELEMENT_TYPE, |
| new Object[] { "CasDataInitializer", initializer.getClass().getName() }, |
| new Exception(CpmLocalizedMessage.getLocalizedMessage( |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_incompatible_component__WARNING", new Object[] { |
| Thread.currentThread().getName(), "CasInitializer", |
| "CasDataInitializer", initializer.getClass().getName() }))); |
| } |
| } |
| // Retrieve number of entities to process from CPE configuration |
| long numDocs2Process = getCPEConfig().getNumToProcess(); |
| if (UIMAFramework.getLogger().isLoggable(Level.CONFIG)) { |
| UIMAFramework.getLogger(this.getClass()).logrb(Level.CONFIG, this.getClass().getName(), |
| "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_show_docs_to_process__CONFIG", |
| new Object[] { Thread.currentThread().getName(), String.valueOf(numDocs2Process) }); |
| } |
| // Provide CollectionReader with the number of documents to process |
| ((ConfigurableResource_ImplBase) colreader).setConfigParameterValue("processSize", |
| new Integer(new Long(numDocs2Process).intValue())); |
| CpeConfiguration cpeType = getCpeDescriptor().getCpeConfiguration(); |
| if (cpeType != null && cpeType.getStartingEntityId() != null |
| && cpeType.getStartingEntityId().trim().length() > 0) { |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(), |
| "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_show_start_doc_id__FINEST", |
| new Object[] { Thread.currentThread().getName(), cpeType.getStartingEntityId() }); |
| } |
| colreader.getProcessingResourceMetaData().getConfigurationParameterSettings() |
| .setParameterValue("startNumber", cpeType.getStartingEntityId().trim()); |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).log( |
| Level.FINEST, |
| "Retrieved Documents Starting with DocId ::" |
| + colreader.getProcessingResourceMetaData() |
| .getConfigurationParameterSettings().getParameterValue( |
| "startNumber")); |
| } |
| } |
| |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).log( |
| Level.FINEST, |
| "Retrieved processSize ::" |
| + ((ConfigurableResource_ImplBase) colreader) |
| .getConfigParameterValue("processSize")); |
| } |
| return colreader; |
| } catch (ResourceConfigurationException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(e); |
| } |
| } |
| |
| /** |
| * Returns an array of Cas Processors instantiated from the cpe descriptor |
| * |
| * @return - array of CasProcessor instances |
| * |
| * @throws ResourceConfigurationException |
| */ |
| public CasProcessor[] getCasProcessors() throws ResourceConfigurationException { |
| checkForErrors(); |
| try { |
| if (getCpeDescriptor().getCpeCasProcessors() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<casProcessors>", "<cpeDescriptor>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_bad_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| CpeCasProcessors ct = getCpeDescriptor().getCpeCasProcessors(); |
| |
| CpeCasProcessor[] casProcessorList = ct.getAllCpeCasProcessors(); |
| Vector v = new Vector(); |
| if (casProcessorList == null || casProcessorList.length == 0) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<casProcessor>", "<casProcessors>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_bad_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| |
| Hashtable namesMap = new Hashtable(); |
| for (int i = 0; i < casProcessorList.length; i++) { |
| CpeCasProcessor processorType = casProcessorList[i]; |
| if (processorType == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "<casProcessor>", "<casProcessors>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_bad_cpe_descriptor__WARNING", new Object[] { Thread |
| .currentThread().getName() }))); |
| } |
| |
| // Check for duplicate Cas Processor names. Names must be unique |
| if (namesMap.containsKey(processorType.getName())) { |
| throw new ResourceConfigurationException(InvalidXMLException.INVALID_CPE_DESCRIPTOR, |
| new Object[] { "casProcessor", "name" }, new CPMException(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_duplicate_name__WARNING", new Object[] { |
| Thread.currentThread().getName(), processorType.getName() }))); |
| } else { |
| namesMap.put(processorType.getName(), processorType.getName()); |
| } |
| |
| String deploymentType = processorType.getDeployment(); |
| if (deploymentType == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.REQUIRED_ATTRIBUTE_MISSING, |
| new Object[] { "deployment", "<casProcessor>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_attribute_from_xml_element__WARNING", |
| new Object[] { Thread.currentThread().getName(), |
| processorType.getName(), "deployment", "casProcessor" }))); |
| } |
| CasProcessor casProcessor = null; |
| String deployModel = ""; |
| boolean cpInMap = false; |
| |
| // Check if the CP has already been instantiated. The map holds one instance of a CP with a |
| // given name |
| // The purpose of the map is to provide access to CP operational parameters. This is needed |
| // to |
| // determine if multiple instances of the CP are allowed. |
| if (cpMap.containsKey(processorType.getName())) { |
| cpInMap = true; // the CasProcessor is in the map |
| casProcessor = (CasProcessor) cpMap.get(processorType.getName()); |
| // Check operational parameters to determine if multiple instances of the CP are allowed |
| if (!casProcessor.getProcessingResourceMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()) { |
| continue; // one instance already created. Multiple instances of this CP not allowed |
| } |
| } |
| |
| if (Constants.DEPLOYMENT_LOCAL.equals(deploymentType.toLowerCase())) { |
| casProcessor = produceLocalCasProcessor(processorType); |
| deployModel = Constants.DEPLOYMENT_LOCAL; |
| } else if (Constants.DEPLOYMENT_INTEGRATED.equals(deploymentType.toLowerCase())) { |
| |
| casProcessor = produceIntegratedCasProcessor(processorType); |
| deployModel = Constants.DEPLOYMENT_INTEGRATED; |
| } else if (Constants.DEPLOYMENT_REMOTE.equals(deploymentType.toLowerCase())) { |
| casProcessor = produceRemoteCasProcessor(processorType); |
| deployModel = Constants.DEPLOYMENT_REMOTE; |
| } else { |
| throw new ResourceConfigurationException(InvalidXMLException.REQUIRED_ATTRIBUTE_MISSING, |
| new Object[] { "deployment", "<casProcessor>" }, new Exception( |
| CpmLocalizedMessage.getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_Exception_invalid_deployment__WARNING", new Object[] { |
| Thread.currentThread().getName(), processorType.getName(), |
| deploymentType }))); |
| } |
| |
| // Add the casProcessor instantiated above to the map. The map is used to check if |
| // multiple instances of the cp are allowed. Need to store an instance in the map |
| // since the only way to determine whether or not multiple instances are allowed is |
| // to check OperationalProperties in the CP metadata. |
| if (!cpInMap) { |
| cpMap.put(processorType.getName(), casProcessor); |
| } |
| |
| String name = casProcessor.getProcessingResourceMetaData().getName(); |
| if (!casProcessorConfigMap.containsKey(name)) { |
| casProcessorConfigMap.put(name, processorType); |
| } else { |
| // Throw an exception due to a non-unique name. CPM requires Cas Processors to have a |
| // unique name. |
| // The unique name enforcement for Local and Remote CP's is done |
| // above 'if ( namesMap.containsKey(processorType.getName()))'. In case of integrated CP, |
| // the |
| // name is taken from the CP descriptor. For Local and Remote, the names are taken from |
| // the |
| // CPE descriptor |
| if (firstTime && Constants.DEPLOYMENT_INTEGRATED.equalsIgnoreCase(deployModel)) { |
| throw new ResourceConfigurationException(new CPMException(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_duplicate_name__WARNING", new Object[] { |
| Thread.currentThread().getName(), processorType.getName() }))); |
| } |
| } |
| |
| v.add(casProcessor); |
| } |
| |
| CasProcessor[] processors = new CasProcessor[v.size()]; |
| v.copyInto(processors); |
| return processors; |
| } catch (ResourceConfigurationException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(e); |
| } finally { |
| firstTime = false; |
| } |
| } |
| |
| /** |
| * Check if a class has appropriate type |
| * |
| * @param aResourceClass - |
| * class to check |
| * @param resourceSpecifier - |
| * specifier containing expected type |
| * @param aDescriptor - |
| * descriptor name |
| * |
| * @return true - if class matches type |
| * |
| * @throws ResourceConfigurationException |
| */ |
| public boolean isDefinitionInstanceOf(Class aResourceClass, ResourceSpecifier resourceSpecifier, |
| String aDescriptor) throws ResourceConfigurationException { |
| boolean validDefinition = false; |
| String implementationClass = null; |
| try { |
| String frameworkName = null; |
| if (resourceSpecifier instanceof AnalysisEngineDescription) { |
| frameworkName = ((AnalysisEngineDescription) resourceSpecifier) |
| .getFrameworkImplementation(); |
| implementationClass = ((AnalysisEngineDescription) resourceSpecifier) |
| .getImplementationName(); |
| } else if (resourceSpecifier instanceof CasConsumerDescription) { |
| frameworkName = ((CasConsumerDescription) resourceSpecifier).getFrameworkImplementation(); |
| implementationClass = ((CasConsumerDescription) resourceSpecifier).getImplementationName(); |
| } else { |
| return false; |
| } |
| |
| if (frameworkName.startsWith(org.apache.uima.Constants.CPP_FRAMEWORK_NAME)) { |
| validDefinition = true; |
| } else { |
| // String className = ((CasConsumerDescription) resourceSpecifier).getImplementationName(); |
| // load class using UIMA Extension ClassLoader if there is one |
| ClassLoader cl = null; |
| ResourceManager rm = getResourceManager(); |
| if (rm != null) { |
| cl = rm.getExtensionClassLoader(); |
| } |
| if (cl == null) { |
| cl = this.getClass().getClassLoader(); |
| } |
| // Class currentClass = Class.forName(className, true, cl); |
| Class currentClass = Class.forName(implementationClass, true, cl); |
| |
| // check to see if this is a subclass of aResourceClass |
| if (aResourceClass.isAssignableFrom(currentClass)) { |
| validDefinition = true; |
| } |
| } |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(ResourceInitializationException.CLASS_NOT_FOUND, |
| new Object[] { implementationClass, aDescriptor }, e); |
| } |
| return validDefinition; |
| } |
| |
| /** |
| * Instantiates CasData Consumer from a given class. |
| * |
| * @param aResourceClass - |
| * CasDataConsumer class |
| * @param aSpecifier - |
| * specifier |
| * @param aAdditionalParams - |
| * parameters used to initialize CasDataConsumer |
| * @return - instance of CasProcessor |
| * |
| * @throws ResourceInitializationException |
| */ |
| public CasProcessor produceCasDataConsumer(Class aResourceClass, ResourceSpecifier aSpecifier, |
| Map aAdditionalParams) throws ResourceInitializationException { |
| String className = null; |
| try { |
| className = ((CasConsumerDescription) aSpecifier).getImplementationName(); |
| // load class using UIMA Extension ClassLoader if there is one |
| ClassLoader cl = null; |
| ResourceManager rm = getResourceManager(); |
| if (rm != null) { |
| cl = rm.getExtensionClassLoader(); |
| } |
| if (cl == null) { |
| cl = this.getClass().getClassLoader(); |
| } |
| Class currentClass = Class.forName(className, true, cl); |
| // check to see if this is a subclass of aResourceClass |
| if (aResourceClass.isAssignableFrom(currentClass)) { |
| // instantiate this Resource Class |
| CasDataConsumer casProcessor = (CasDataConsumer) currentClass.newInstance(); |
| |
| // attempt to initialize it |
| if (casProcessor.initialize(aSpecifier, aAdditionalParams)) { |
| // success! |
| return casProcessor; |
| } |
| } |
| } |
| // if an exception occurs, log it but do not throw it... yet |
| catch (ClassNotFoundException e) { |
| throw new ResourceInitializationException(ResourceInitializationException.CLASS_NOT_FOUND, |
| new Object[] { className, aSpecifier.getSourceUrlString() }, e); |
| } catch (IllegalAccessException e) { |
| throw new ResourceInitializationException( |
| ResourceInitializationException.COULD_NOT_INSTANTIATE, new Object[] { className, |
| aSpecifier.getSourceUrlString() }, e); |
| } catch (InstantiationException e) { |
| throw new ResourceInitializationException( |
| ResourceInitializationException.COULD_NOT_INSTANTIATE, new Object[] { className, |
| aSpecifier.getSourceUrlString() }, e); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Instantiates Cas Initializer from a given class. It return |
| * |
| * @param aSpecifier - |
| * configuration for Cas Initializer |
| * @param aAdditionalParams - |
| * parameters to initialize Cas Initializer |
| * |
| * @return instance of CasDataInitializer or CasInitializer |
| * @throws ResourceInitializationException |
| */ |
| private Object produceInitializer(ResourceSpecifier aSpecifier, Map aAdditionalParams) |
| throws ResourceInitializationException { |
| String className = null; |
| try { |
| className = ((CasInitializerDescription) aSpecifier).getImplementationName(); |
| // load class using UIMA Extension ClassLoader if there is one |
| ClassLoader cl = null; |
| ResourceManager rm = getResourceManager(); |
| if (rm != null) { |
| cl = rm.getExtensionClassLoader(); |
| } |
| if (cl == null) { |
| cl = this.getClass().getClassLoader(); |
| } |
| Class currentClass = Class.forName(className, true, cl); |
| Object initializer = currentClass.newInstance(); |
| // check to see if this is a subclass of aResourceClass |
| if (initializer instanceof CasInitializer) { |
| ((CasInitializer) initializer).initialize(aSpecifier, aAdditionalParams); |
| return initializer; |
| } else if (initializer instanceof CasDataInitializer) { |
| ((CasDataInitializer) initializer).initialize(aSpecifier, aAdditionalParams); |
| return initializer; |
| } else { |
| throw new InstantiationException("Unexpected CasInitializer-" |
| + initializer.getClass().getName()); |
| } |
| } |
| // if an exception occurs, log it but do not throw it... yet |
| catch (ClassNotFoundException e) { |
| throw new ResourceInitializationException(ResourceInitializationException.CLASS_NOT_FOUND, |
| new Object[] { className, aSpecifier.getSourceUrlString() }, e); |
| } catch (IllegalAccessException e) { |
| throw new ResourceInitializationException( |
| ResourceInitializationException.COULD_NOT_INSTANTIATE, new Object[] { className, |
| aSpecifier.getSourceUrlString() }, e); |
| } catch (InstantiationException e) { |
| throw new ResourceInitializationException( |
| ResourceInitializationException.COULD_NOT_INSTANTIATE, new Object[] { className, |
| aSpecifier.getSourceUrlString() }, e); |
| } |
| } |
| |
| /** |
| * Returns a descriptor path associated with Cas Processor |
| * |
| * @param aCasProcessorCfg - |
| * Cas Processor configuration |
| * @return - Descriptor path |
| * |
| * @throws ResourceConfigurationException |
| */ |
| public URL getDescriptorURL(CpeCasProcessor aCasProcessorCfg) |
| throws ResourceConfigurationException { |
| if (aCasProcessorCfg.getCpeComponentDescriptor() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, new Object[] { |
| "descriptor", "casProcessor" }, new Exception(CpmLocalizedMessage.getLocalizedMessage( |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_EXP_missing_xml_element__WARNING", |
| new Object[] { Thread.currentThread().getName(), aCasProcessorCfg.getName(), |
| "descriptor" }))); |
| } |
| return aCasProcessorCfg.getCpeComponentDescriptor().findAbsoluteUrl(getResourceManager()); |
| } |
| |
| /** |
| * Instantiates a ResourceSpecifier from a given URL. |
| * |
| * @param aDescriptorURL - URL of descriptor |
| * @return - ResourceSpecifier |
| * |
| * @throws Exception |
| */ |
| public ResourceSpecifier getSpecifier(URL aDescriptorUrl) throws Exception { |
| XMLInputSource in = new XMLInputSource(aDescriptorUrl); |
| return UIMAFramework.getXMLParser().parseResourceSpecifier(in); |
| |
| } |
| |
| /** |
| * Instantiates a local (managed) Cas Processor |
| * |
| * @param aCasProcessorCfg - |
| * Cas Processor configuration |
| * @return - Local CasProcessor |
| * |
| * @throws ResourceConfigurationException |
| */ |
| private CasProcessor produceLocalCasProcessor(CpeCasProcessor aCasProcessorCfg) |
| throws ResourceConfigurationException { |
| if (aCasProcessorCfg == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, new Object[] { |
| "casProcessor", "casProcessors" }, new Exception(CpmLocalizedMessage.getLocalizedMessage( |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_EXP_bad_cpe_descriptor_no_cp__WARNING", |
| new Object[] { Thread.currentThread().getName() }))); |
| } |
| CasProcessor casProcessor = new NetworkCasProcessorImpl(aCasProcessorCfg); |
| return casProcessor; |
| } |
| |
| /** |
| * Find a parameter with a given name in the in-memory component descriptor |
| * |
| * @param aCps - |
| * parameter settings from the component's descriptor |
| * @param aParamName - |
| * name of the parameter to look for |
| * |
| * @return - parameter as {@link NameValuePair} instance. If not found, returns null. |
| * |
| * @throws Exception - |
| * any error |
| */ |
| private NameValuePair findMatchingNameValuePair(ConfigurationParameterSettings aCps, |
| String aParamName) throws Exception { |
| |
| NameValuePair[] nvp = aCps.getParameterSettings(); |
| |
| // Find a parameter with a given name |
| for (int i = 0; nvp != null && i < nvp.length; i++) { |
| if (nvp[i].getName() != null) { |
| if (nvp[i].getName().equalsIgnoreCase(aParamName)) { |
| return nvp[i]; // Found it |
| } |
| } |
| } |
| return null; // Parameter with a given name does not exist |
| } |
| |
| /** |
| * Replace a primitive value of a given parameter with a value defined in the CPE descriptor |
| * |
| * @param aType - |
| * type of the primitive value ( String, Integer, Boolean, or Float) |
| * @param aCps - |
| * parameter settings from the component's descriptor |
| * @param aCPE_nvp - |
| * parameter containing array of values to replace values in the component's descriptor |
| * @throws Exception |
| */ |
| private void replacePrimitive(String aType, boolean aMandatoryParam, |
| ConfigurationParameterSettings aCps, |
| org.apache.uima.collection.metadata.NameValuePair aCPE_nvp, |
| String aComponentName) throws Exception { |
| boolean newParamSetting = false; |
| |
| // Get a new value for the primitive param |
| Object aValueObject = aCPE_nvp.getValue(); |
| String param_name = aCPE_nvp.getName(); |
| |
| // Find corresponding parameter in the in-memory component descriptor |
| NameValuePair nvp = findMatchingNameValuePair(aCps, param_name.trim()); |
| if (nvp == null) { |
| newParamSetting = true; |
| nvp = new NameValuePair_impl(); |
| nvp.setName(param_name); |
| } |
| // Copy a new value based on type |
| if (aType.equals("String") && aValueObject instanceof String) { |
| nvp.setValue(aValueObject); |
| } else if (aType.equals("Integer") && aValueObject instanceof Integer) { |
| nvp.setValue(aValueObject); |
| } else if (aType.equals("Float") && aValueObject instanceof Float) { |
| nvp.setValue(aValueObject); |
| |
| } else if (aType.equals("Boolean") && aValueObject instanceof Boolean) { |
| nvp.setValue(aValueObject); |
| } |
| |
| if (newParamSetting) { |
| aCps.setParameterValue(null, nvp.getName(), nvp.getValue()); |
| } |
| } |
| |
| /** |
| * Replace array values found in the component's descriptor with values found in the CPE |
| * descriptor |
| * |
| * @param aType - |
| * primitive type of the array (Sting, Integer, Float, or Boolean) |
| * @param aCps - |
| * parameter settings from the component's descriptor |
| * @param aCPE_nvp - |
| * parameter containing array of values to replace values in the component's descriptor |
| * |
| * @throws Exception - |
| * any error |
| */ |
| private void replaceArray(String aType, boolean aMandatoryParam, |
| ConfigurationParameterSettings aCps, |
| org.apache.uima.collection.metadata.NameValuePair aCPE_nvp, |
| String aComponentName) throws Exception { |
| boolean newParamSetting = false; |
| Object valueObject = aCPE_nvp.getValue(); |
| String param_name = aCPE_nvp.getName(); |
| // Find in the component in-memory descriptor a parameter with a given name |
| NameValuePair nvp = findMatchingNameValuePair(aCps, param_name.trim()); |
| if (nvp == null) { |
| // Parameter setting does not exist in the component's descriptor so create new |
| newParamSetting = true; |
| nvp = new NameValuePair_impl(); |
| nvp.setName(param_name); |
| } |
| // Override component's parameters based on type |
| if (aType.equals("String") && valueObject instanceof String[]) { |
| nvp.setValue(valueObject); |
| } else if (aType.equals("Integer") && valueObject instanceof Integer[]) { |
| nvp.setValue(valueObject); |
| } else if (aType.equals("Float") && valueObject instanceof Float[]) { |
| nvp.setValue(valueObject); |
| } else if (aType.equals("Boolean") && valueObject instanceof Boolean[]) { |
| nvp.setValue(valueObject); |
| } |
| if (newParamSetting) { |
| aCps.setParameterValue(null, nvp.getName(), nvp.getValue()); |
| } |
| |
| } |
| |
| /** |
| * Override component's parameters. This overridde effects the in-memory settings. The actual |
| * component's descriptor will not be changed. |
| * |
| * @param aResourceSpecifier - |
| * in-memory descriptor of the component |
| * @param aCPE_nvp - |
| * parameter represented as name-value pair. If the name of the parameter is found in the |
| * component's descriptor its value will be changed. |
| * |
| * @throws Exception - |
| * error during processing |
| */ |
| private boolean overrideParameterIfExists(ResourceSpecifier aResourceSpecifier, |
| org.apache.uima.collection.metadata.NameValuePair aCPE_nvp, |
| String aComponentName) throws Exception { |
| // Retrieve component's parameter settings from the in-memory descriptor |
| ConfigurationParameterDeclarations cpd = ((ResourceCreationSpecifier) aResourceSpecifier) |
| .getMetaData().getConfigurationParameterDeclarations(); |
| // Get the name of the parameter to find in the component's parameter list |
| String param_name = aCPE_nvp.getName().trim(); |
| // Extract parameter with a matching name from the parameter declaration section of the |
| // component's descriptor |
| ConfigurationParameter cparam = cpd.getConfigurationParameter(null, param_name); |
| if (cparam != null) { |
| // Retrieve component's parameter settings from the in-memory descriptor |
| ConfigurationParameterSettings cps = ((ResourceCreationSpecifier) aResourceSpecifier) |
| .getMetaData().getConfigurationParameterSettings(); |
| // Determie if it is a multi-value parameter (array) |
| boolean isMultiValue = cparam.isMultiValued(); |
| // Check if there is a match based on param name |
| if (cparam.getName().equals(param_name)) { |
| boolean mandatory = cparam.isMandatory(); |
| if (isMultiValue) { |
| // Override array with values from the CPE descriptor |
| replaceArray(cparam.getType(), mandatory, cps, aCPE_nvp, aComponentName); |
| } else { |
| // Override primitive parameter with value from the CPE descriptor |
| replacePrimitive(cparam.getType(), mandatory, cps, aCPE_nvp, |
| aComponentName); |
| } |
| return true; // Found a match and did the override |
| } |
| |
| } |
| return false; // The parameter does not exist in the component's descriptor |
| } |
| |
| /** |
| * Replace component's parameters. Its parameter values will be changed to match those defined in |
| * the CPE descriptor. |
| * |
| * @param aResourceSpecifier - |
| * component's descriptor containing parameters to override |
| * @param aCasProcessorCPEConfig - |
| * cas processor configuration containing optional parameters to be used for overriding |
| * parameters in the descriptor |
| * @throws Exception - |
| * failure during processing |
| */ |
| private void overrideParameterSettings(ResourceSpecifier aResourceSpecifier, |
| CasProcessorConfigurationParameterSettings aCpe_cps, |
| String aComponentName) throws Exception { |
| |
| if (aCpe_cps != null && aCpe_cps.getParameterSettings() != null) { |
| // Extract new parameters from the CPE descriptor |
| // Parameters are optional, so test and do the override if necessary |
| org.apache.uima.collection.metadata.NameValuePair[] nvp = aCpe_cps.getParameterSettings(); |
| |
| for (int i = 0; i < nvp.length; i++) { |
| // Next parameter to overridde |
| if (nvp[i] != null) { |
| overrideParameterIfExists(aResourceSpecifier, nvp[i], aComponentName); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Instantiates integrated Cas Processor |
| * |
| * @param aCasProcessorCfg - |
| * Cas processor configuration |
| * @return - Integrated CasProcessor |
| * @throws ResourceConfigurationException |
| */ |
| private CasProcessor produceIntegratedCasProcessor(CpeCasProcessor aCasProcessorType) |
| throws ResourceConfigurationException { |
| CasProcessor casProcessor = null; |
| ResourceSpecifier resourceSpecifier = null; |
| try { |
| if (aCasProcessorType != null) { |
| URL descriptorUrl = getDescriptorURL(aCasProcessorType); |
| resourceSpecifier = getSpecifier(descriptorUrl); |
| |
| CpeSofaMappings sofanamemappings = aCasProcessorType.getSofaNameMappings(); |
| HashMap sofamap = new HashMap(); |
| if (sofanamemappings != null) { |
| CpeSofaMapping[] sofaNameMappingArray = sofanamemappings.getSofaNameMappings(); |
| for (int i = 0; sofaNameMappingArray != null && i < sofaNameMappingArray.length; i++) { |
| CpeSofaMapping aSofaMap = sofaNameMappingArray[i]; |
| // if no component sofa name, then set it to default |
| if (aSofaMap.getComponentSofaName() == null) |
| aSofaMap.setComponentSofaName(CAS.NAME_DEFAULT_TEXT_SOFA); |
| sofamap.put(aSofaMap.getComponentSofaName(), aSofaMap.getCpeSofaName()); |
| } |
| } |
| |
| // Replace parameters in component descriptor with values defined in the CPE descriptor |
| overrideParameterSettings(resourceSpecifier, aCasProcessorType |
| .getConfigurationParameterSettings(), "CasProcessor:" |
| + aCasProcessorType.getName()); |
| |
| // create child UimaContext and insert into mInitParams map |
| UimaContextAdmin childContext = uimaContext.createChild(aCasProcessorType.getName(), |
| sofamap); |
| Map additionalParams = new HashMap(); |
| additionalParams.put(Resource.PARAM_UIMA_CONTEXT, childContext); |
| |
| // need this check to do specific CasDataConsumer processing |
| if (resourceSpecifier instanceof CasConsumerDescription |
| && !isDefinitionInstanceOf(CasConsumer.class, resourceSpecifier, descriptorUrl.toString())) { |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(), |
| "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_producing_cas_data_consumer__FINEST", |
| new Object[] { Thread.currentThread().getName() }); |
| } |
| casProcessor = produceCasDataConsumer(CasProcessor.class, resourceSpecifier, |
| additionalParams); |
| } else { |
| // Except for CasDataConsumers, everything else is treated as an AnalysisEngine. |
| // This includes CAS Consumers, which will automatically be wrapped inside AnalysisEngines |
| // by the produceAnalysisEngine method. It also handles UriSpecifiers for |
| // remote services (for either AE or CAS Consumer) |
| casProcessor = UIMAFramework.produceAnalysisEngine(resourceSpecifier, |
| getResourceManager(), additionalParams); |
| } |
| |
| // Check if CasProcesser has been instantiated |
| if (casProcessor == null) { |
| |
| throw new ResourceConfigurationException(new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_instantiation_exception__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorType.getName() }))); |
| } |
| } |
| } catch (ResourceConfigurationException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new ResourceConfigurationException( |
| ResourceInitializationException.CAS_PROCESSOR_INITIALIZE_FAILED, |
| new Object[] { aCasProcessorType.getName() }, e); |
| } |
| // Override the name of the component with the name specified in the cpe descriptor |
| // Uniqueness of names is enforced on names in the cpe descriptor not those defined |
| // in the component descriptor |
| casProcessor.getProcessingResourceMetaData().setName(aCasProcessorType.getName()); |
| |
| return casProcessor; |
| |
| } |
| |
| /** |
| * Instantiates remote Cas Processor |
| * |
| * @param aCasProcessorCfg - |
| * Cas Processor Configuration |
| * @return - Remote CasProcessor |
| * |
| * @throws ResourceConfigurationException |
| */ |
| private CasProcessor produceRemoteCasProcessor(CpeCasProcessor aCasProcessorType) |
| throws ResourceConfigurationException { |
| String protocol = DeployFactory.getProtocol(aCasProcessorType, getResourceManager()); |
| CasProcessor casProcessor = null; |
| if (Constants.SOCKET_PROTOCOL.equalsIgnoreCase(protocol)) { |
| casProcessor = new CasObjectNetworkCasProcessorImpl(aCasProcessorType); |
| } else { |
| // For remote Cas Processor make sure that the required parameters are defined. |
| // Specifically, VNS host and port are required. Do validation now. If it fails, the |
| // ResourceConfigurationException is thrown and we are out here. |
| // verifyDeploymentParams(aCasProcessorType.getName(), |
| // aCasProcessorType.getDeploymentParameters()); |
| casProcessor = new NetworkCasProcessorImpl(aCasProcessorType); |
| } |
| return casProcessor; |
| } |
| |
| /** |
| * Returns an object containing global CPE configuration including: |
| * <li>Number of documents to process</li> |
| * <li>Checkpoint configuration</li> |
| * <li>id of the document begin processing</li> |
| * |
| * @return - Global CPE Configuration |
| * @throws InstantiationException |
| */ |
| public CpeConfiguration getCPEConfig() throws InstantiationException { |
| try { |
| return getCpeDescriptor().getCpeConfiguration(); |
| } catch (Exception e) { |
| throw new InstantiationException(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Returns number of processing threads (Processing Units) |
| * |
| * @return Number of processing threads |
| * |
| * @throws ResourceConfigurationException |
| */ |
| public int getProcessingUnitThreadCount() throws ResourceConfigurationException { |
| int threadCount; |
| |
| try { |
| threadCount = this.getCpeDescriptor().getCpeCasProcessors().getConcurrentPUCount(); |
| } catch (Exception e) { |
| |
| throw new ResourceConfigurationException(InvalidXMLException.REQUIRED_ATTRIBUTE_MISSING, |
| new Object[] { "processingUnitThreadCount" }, new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_attribute_from_xml_element__WARNING", |
| new Object[] { Thread.currentThread().getName(), "casProcessors", |
| "processingUnitThreadCount", "<casProcessors>", }))); |
| } |
| |
| return threadCount; |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public boolean isDefault() { |
| return defaultConfig; |
| } |
| |
| /** |
| * Returns Cpe Descriptor |
| * |
| * @return |
| */ |
| public CpeDescription getCpeDescriptor() { |
| return cpeDescriptor; |
| } |
| |
| /** |
| * Assigns Cpe configuration to use |
| * |
| * @param description |
| */ |
| private void setCpeDescriptor(CpeDescription description) { |
| cpeDescriptor = description; |
| } |
| |
| /** |
| * Checks uniqueness of a given name. This name is compared against all Cas Processors already |
| * defined. Cas Processor names must be unique. |
| * |
| * @param aName - |
| * name to check |
| * @return - true if name is unique, false otherwise |
| * |
| */ |
| private boolean isUniqueName(String aName) throws CpeDescriptorException { |
| int index = 0; |
| if (getCpeDescriptor().getCpeCasProcessors() != null |
| && getCpeDescriptor().getCpeCasProcessors().getAllCpeCasProcessors() != null) { |
| index = getCpeDescriptor().getCpeCasProcessors().getAllCpeCasProcessors().length; |
| } |
| for (int i = 0; i < index; i++) { |
| CpeCasProcessor processor = getCpeDescriptor().getCpeCasProcessors().getCpeCasProcessor(i); |
| String name = processor.getName(); |
| if (name != null && name.equalsIgnoreCase(aName)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Checks for existance of two parameters required to launch remote Cas Processor vnsHost and |
| * vnsPort. If not found the remote CasProcessor can not be located since the VNS is not |
| * specified. In this case an exception is thrown. |
| * |
| * @param aCasProcessorName |
| * @param aDepParams |
| * @throws ResourceConfigurationException |
| */ |
| private void verifyDeploymentParams(String aCasProcessorName, |
| CasProcessorDeploymentParams aDepParams) throws ResourceConfigurationException { |
| if (aDepParams == null) { |
| throw new ResourceConfigurationException(new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_xml_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorName, |
| "<deploymentParameters>" }))); |
| } |
| if (aDepParams == null || aDepParams.getAll() == null) { |
| return; // nothing to do |
| } |
| |
| try { |
| CasProcessorDeploymentParam param = aDepParams.get(Constants.VNS_HOST); |
| if (param == null || param.getParameterValue() == null |
| || param.getParameterValue().trim().length() == 0) { |
| throw new ResourceConfigurationException( |
| ResourceInitializationException.CONFIG_SETTING_ABSENT, |
| new Object[] { "parameter" }, new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_deploy_params_not_defined__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorName, |
| Constants.VNS_HOST }))); |
| |
| } |
| param = aDepParams.get(Constants.VNS_PORT); |
| if (param == null || param.getParameterValue() == null |
| || param.getParameterValue().trim().length() == 0) { |
| throw new ResourceConfigurationException( |
| ResourceInitializationException.CONFIG_SETTING_ABSENT, |
| new Object[] { "parameter" }, new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_deploy_params_not_defined__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorName, |
| Constants.VNS_PORT }))); |
| |
| } |
| } catch (ResourceConfigurationException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(e); |
| } |
| // for (int i = 0; i < totalParamCount; i++) |
| // { |
| // parameter param = aDepParams.getParameter(i); |
| // if (Constants.VNS_HOST.equals(param.getName()) && param.getValue() != null && |
| // param.getValue().trim().length() > 0) |
| // { |
| // vnsHostFound = true; |
| // } |
| // else if (Constants.VNS_PORT.equals(param.getName()) && param.getValue() != null && |
| // param.getValue().trim().length() > 0) |
| // { |
| // vnsPortFound = true; |
| // } |
| // } |
| // // Check if required params have been found |
| // if (!vnsHostFound || !vnsPortFound) |
| // { |
| // if (!vnsHostFound) |
| // { |
| // throw new |
| // ResourceConfigurationException(ResourceInitializationException.CONFIG_SETTING_ABSENT, new |
| // Object[] { "parameter" }, new Exception("Remote CasProcessor:'" + aCasProcessorName + "' not |
| // configured completely.Section '<deploymentParameters>' missing " + Constants.VNS_HOST + " |
| // parameter and its value")); |
| // } |
| // if (!vnsPortFound) |
| // { |
| // throw new |
| // ResourceConfigurationException(ResourceInitializationException.CONFIG_SETTING_ABSENT, new |
| // Object[] { "parameter" }, new Exception("Remote CasProcessor:'" + aCasProcessorName + "' not |
| // configured completely.Section '<deploymentParameters>' missing " + Constants.VNS_PORT + " |
| // parameter and its value")); |
| // } |
| // |
| // } |
| |
| } |
| |
| /** |
| * Appends given Cas Processor to the list of CasProcessors |
| * |
| * @param aCasProcessor - |
| * CasProcessor to add |
| */ |
| public void addCasProcessor(CasProcessor aCasProcessor) throws ResourceConfigurationException { |
| if (!initialized) { |
| addCasProcessor(aCasProcessor.getProcessingResourceMetaData().getName()); |
| } |
| } |
| |
| /** |
| * Adds new Cas Processor with given name. |
| * |
| * @param aCasProcessorName - |
| * name of the CasProcessor to add |
| * |
| * @return - |
| */ |
| private CpeCasProcessor addCasProcessor(String aCasProcessorName) |
| throws ResourceConfigurationException { |
| CpeCasProcessor newProcessor = null; |
| try { |
| if (!isUniqueName(aCasProcessorName)) { |
| throw new ResourceConfigurationException(new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_duplicate_name__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorName }))); |
| } |
| int index = getCpeDescriptor().getCpeCasProcessors().getAllCpeCasProcessors().length; // getcasProcessorCount(); |
| |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).logrb( |
| Level.FINEST, |
| this.getClass().getName(), |
| "initialize", |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_add_cp_with_index__FINEST", |
| new Object[] { Thread.currentThread().getName(), aCasProcessorName, |
| String.valueOf(index) }); |
| } |
| CpeCasProcessor processor = getCpeDescriptor().getCpeCasProcessors().getCpeCasProcessor( |
| index - 1); |
| |
| if (processor.getCheckpoint() == null) { |
| throw new ResourceConfigurationException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[] { "checkpoint", "casProcessor" }, new Exception(CpmLocalizedMessage |
| .getLocalizedMessage(CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_EXP_missing_xml_element__WARNING", new Object[] { |
| Thread.currentThread().getName(), aCasProcessorName, |
| "<checkpoint>" }))); |
| } |
| |
| // For remote Cas Processor make sure that the required parameters are defined. |
| // Specifically, VNS host and port are required. Do validation now. If it fails, the |
| // ResourceConfigurationException is thrown and we are out here. |
| if (Constants.DEPLOYMENT_REMOTE.equals(processor.getDeployment())) { |
| String protocol = DeployFactory.getProtocol(processor, getResourceManager()); |
| if (Constants.VINCI_PROTOCOL.equals(protocol)) { |
| verifyDeploymentParams(aCasProcessorName, processor.getDeploymentParams()); |
| } |
| } |
| |
| if (processorCount == 0) { |
| newProcessor = processor; |
| copyCasProcessor(newProcessor, aCasProcessorName); |
| } else { |
| // CpeCasProcessor cloneProcessor = |
| // getCpeDescriptor().getCpeCasProcessors().getCpeCasProcessor(0); |
| |
| newProcessor = new CpeIntegratedCasProcessorImpl(); |
| newProcessor.setDescriptor("href"); |
| // // Clone casProcessor from an existing one |
| // newProcessor = cpeDescGen.createcasProcessor(cloneProcessor); |
| copyCasProcessor(newProcessor, aCasProcessorName); |
| getCpeDescriptor().getCpeCasProcessors().addCpeCasProcessor(newProcessor, processorCount);// setCpeCasProcessor(processorCount, |
| // newProcessor); |
| } |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).log( |
| Level.FINEST, |
| "getCpeDescriptor().getCasProcessors().getCasProcessor.getAttributeValue(name) " |
| + " " |
| + getCpeDescriptor().getCpeCasProcessors().getCpeCasProcessor( |
| processorCount).getAttributeValue("name")); |
| UIMAFramework |
| .getLogger(this.getClass()) |
| .log( |
| Level.FINEST, |
| "getCpeDescriptor().getCasProcessors().getCasProcessor(" |
| + "processorCount).getErrorHandling().getMaxConsecutiveRestarts().getAction() " |
| + " " |
| + getCpeDescriptor().getCpeCasProcessors().getCpeCasProcessor( |
| processorCount).getErrorHandling() |
| .getMaxConsecutiveRestarts().getAction()); |
| } |
| if (!casProcessorConfigMap.containsKey(aCasProcessorName)) { |
| casProcessorConfigMap.put(aCasProcessorName, getCpeDescriptor().getCpeCasProcessors() |
| .getCpeCasProcessor(processorCount)); |
| } |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(e); |
| } |
| processorCount++; |
| return newProcessor; |
| } |
| |
| /** |
| * |
| * @param aList |
| * @return |
| * @throws ResourceConfigurationException |
| */ |
| public String getDescriptor(List aList) throws ResourceConfigurationException { |
| if (aList.size() == 0) { |
| return ""; |
| } |
| |
| try { |
| String[] colReader = (String[]) aList.get(0); |
| String[] casInitializer = (String[]) aList.get(1); |
| |
| getCpeDescriptor().getAllCollectionCollectionReaders()[0].getCollectionIterator() |
| .getDescriptor().getInclude().set(colReader[0]); |
| // Populate collection iterator descriptor path |
| // Populate collection initializer descriptor path |
| if (casInitializer[0].length() > 0) { |
| getCpeDescriptor().getAllCollectionCollectionReaders()[0].getCasInitializer() |
| .getDescriptor().getInclude().set(casInitializer[0]); |
| } else { |
| getCpeDescriptor().getAllCollectionCollectionReaders()[0].removeCasInitializer(); |
| } |
| |
| int procIndex = 2; |
| // First check if casProcessors have been previously been added. If not, add them |
| // to a descriptor. |
| boolean create = false; |
| int numProcessors = 0; |
| CpeCasProcessors processorList = getCpeDescriptor().getCpeCasProcessors(); |
| // Check if added casProcessors using addCasProcessor API. If not create needed |
| // casProcessors and add descriptor paths |
| if (processorCount == 0) { |
| create = true; |
| // the list contains two other entires besides casProcessors. Namely collection iterator |
| // and cas Initializer. So to get # of casProcessors in the list subtract 2 non-casProcessor |
| // entries. |
| numProcessors = aList.size() - procIndex; |
| } else { |
| numProcessors = processorList.getAllCpeCasProcessors().length; |
| } |
| CpeCasProcessor newProcessor = null; |
| |
| // Now add each casProcessor to a descriptor |
| for (int i = 0; i < numProcessors; i++) { |
| String[] casProcInfo = (String[]) aList.get(procIndex + i); |
| if (create) { |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(), |
| "initialize", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_create_new_cp_from_list__FINEST", |
| new Object[] { Thread.currentThread().getName(), casProcInfo[0] }); |
| } |
| // The list suppose to contain an array of Strings of size 2. |
| // Where the the first element is the name of the CasProcessor |
| // and the second is the descriptor path |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(), |
| "initialize", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_add_cp_from_list__FINEST", |
| new Object[] { Thread.currentThread().getName(), casProcInfo[0] }); |
| } |
| newProcessor = addCasProcessor(casProcInfo[0]); |
| } else { |
| newProcessor = processorList.getCpeCasProcessor(i); |
| } |
| if (newProcessor != null) { |
| newProcessor.setDescriptor(casProcInfo[1]); |
| } |
| } |
| |
| if (create) { |
| // Set global flag as an indicator that the CPE Descriptor has been instantiated |
| initialized = true; |
| } |
| ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
| |
| getCpeDescriptor().toXML(bos); |
| |
| return bos.toString(); |
| |
| } catch (Exception e) { |
| throw new ResourceConfigurationException(e); |
| } |
| } |
| |
| /** |
| * @param newProcessor |
| * @param aCasProcessor |
| */ |
| private void copyCasProcessor(CpeCasProcessor aProcDesc, String aName) { |
| try { |
| aProcDesc.setName(aName); |
| if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) { |
| UIMAFramework.getLogger(this.getClass()) |
| .logrb( |
| Level.FINEST, |
| this.getClass().getName(), |
| "initialize", |
| CPMUtils.CPM_LOG_RESOURCE_BUNDLE, |
| "UIMA_CPM_show_cp_deployment__FINEST", |
| new Object[] { Thread.currentThread().getName(), aName, |
| aProcDesc.getDeployment() }); |
| } |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * |
| * |
| * @param collectionReader - |
| * collection reader to use by the CPM |
| */ |
| public void addCollectionReader(BaseCollectionReader collectionReader) { |
| // nothing done as of now; If there is any field that will be accessed |
| // this method can be implemented to copy the values similar to addCasProcessod |
| |
| } |
| |
| /** |
| * Gets the ResourceManager that all components of this CPE should share. |
| * |
| * @return |
| */ |
| public ResourceManager getResourceManager() { |
| return uimaContext.getResourceManager(); |
| } |
| |
| } |
