| /* |
| * 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. |
| */ |
| |
| /** |
| * |
| * Project UIMA Tooling |
| * |
| * |
| * creation date: Apr 4, 2007, 8:52:46 PM |
| * source: AEDeployment_Impl.java |
| */ |
| /* |
| * 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.aae.deployment.impl; |
| |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.uima.UIMAFramework; |
| import org.apache.uima.aae.deployment.AEDeploymentConstants; |
| import org.apache.uima.aae.deployment.AEDeploymentMetaData; |
| import org.apache.uima.aae.deployment.AsyncAEErrorConfiguration; |
| import org.apache.uima.aae.deployment.AsyncAggregateErrorConfiguration; |
| import org.apache.uima.aae.deployment.AsyncPrimitiveErrorConfiguration; |
| import org.apache.uima.aae.deployment.RemoteAEDeploymentMetaData; |
| import org.apache.uima.analysis_engine.AnalysisEngineDescription; |
| import org.apache.uima.analysis_engine.metadata.AnalysisEngineMetaData; |
| import org.apache.uima.resource.ResourceCreationSpecifier; |
| import org.apache.uima.resource.ResourceManager; |
| import org.apache.uima.resource.ResourceSpecifier; |
| import org.apache.uima.resource.metadata.Import; |
| import org.apache.uima.resource.metadata.OperationalProperties; |
| import org.apache.uima.resource.metadata.impl.MetaDataObject_impl; |
| import org.apache.uima.resource.metadata.impl.PropertyXmlInfo; |
| import org.apache.uima.resource.metadata.impl.XmlizationInfo; |
| import org.apache.uima.tools.debug.util.Trace; |
| import org.apache.uima.util.InvalidXMLException; |
| import org.apache.uima.util.XMLParser; |
| import org.apache.uima.util.XMLizable; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.helpers.AttributesImpl; |
| |
| |
| /** |
| * |
| * |
| */ |
| public class AEDeploymentMetaData_Impl extends DeploymentMetaData_Impl implements |
| AEDeploymentConstants, AEDeploymentMetaData { |
| protected boolean topAnalysisEngine = false; |
| |
| protected boolean async = DEFAULT_ASYNC; |
| |
| protected boolean issetAsync = false; |
| |
| protected int numberOfInstances = DEFAULT_SCALEOUT_INSTANCES; |
| |
| protected boolean casMultiplier = false; |
| |
| protected int casMultiplierPoolSize = DEFAULT_CAS_MULTIPLIER_POOL_SIZE; |
| |
| protected int initialFsHeapSize = DEFAULT_CAS_INITIAL_HEAP_SIZE; |
| |
| protected boolean processParentCASLast = false; |
| |
| protected AEDelegates_Impl delegates; |
| |
| protected AsyncAEErrorConfiguration asyncAEErrorConfiguration; |
| |
| protected ResourceSpecifier resourceSpecifier; |
| |
| protected Import importedAE; // import by location|name of AE descriptor |
| |
| protected int inputQueueScaleout = -1; |
| |
| protected int internalReplyQueueScaleout = -1; |
| |
| /** ********************************************************************** */ |
| |
| /** |
| * |
| */ |
| public AEDeploymentMetaData_Impl() { |
| } |
| |
| public boolean isSet(int i) { |
| return i != UNDEFINED_INT; |
| } |
| |
| public ResourceSpecifier getResourceSpecifier() { |
| return resourceSpecifier; |
| } |
| |
| public void setResourceSpecifier(ResourceSpecifier rs, ResourceManager aResourceManager, |
| boolean recursive) throws InvalidXMLException { |
| resourceSpecifier = rs; |
| |
| setCasMultiplier(AEDeploymentDescription_Impl.isCASMultiplier(rs)); |
| // if (AEDeploymentDescription_Impl.isCASMultiplier(rs)) { |
| // setCasMultiplierPoolSize(DEFAULT_CAS_MULTIPLIER_POOL_SIZE); |
| // } |
| |
| if ( (rs instanceof AnalysisEngineDescription) && recursive ) { |
| resolveDelegatesInternal((AnalysisEngineDescription) rs, aResourceManager, recursive); |
| } |
| } |
| |
| public void resolveDelegates(ResourceManager aResourceManager, boolean recursive) |
| throws InvalidXMLException { |
| if (getResourceSpecifier() == null) { |
| Trace.err(getKey() + ": NO AnalysisEngineDescription"); |
| return; |
| } |
| ResourceSpecifier rs1 = getResourceSpecifier(); |
| if (!(rs1 instanceof AnalysisEngineDescription)) { |
| // Need to be Aggregate AE |
| return; |
| } |
| |
| // Resolve Imports |
| AnalysisEngineDescription aed = (AnalysisEngineDescription) rs1; |
| aed.resolveImports(aResourceManager); |
| Map mapDelegateAEs = aed.getDelegateAnalysisEngineSpecifiers(aResourceManager); |
| |
| // Verify that delegates exist in AnalysisEngineDescription aed |
| if (delegates != null) { |
| for (String key: delegates.delegateKeys) { |
| if ( ! mapDelegateAEs.containsKey(key) ) { |
| Trace.err(" >>> " + key + " is not in" + aed.getAnalysisEngineMetaData().getName()); |
| throw new DDEInvalidXMLException(DDEInvalidXMLException.DELEGATE_KEY_NOT_FOUND, new |
| Object[] { |
| key, aed.getSourceUrlString() }); |
| } |
| } |
| } else { |
| delegates = new AEDelegates_Impl(this); |
| } |
| |
| // Set the ResourceSpecifier of each AEDeploymentMetaData|RemoteAEDeploymentMetaData delegate |
| for (Object m : mapDelegateAEs.entrySet()) { |
| Map.Entry entry = (Map.Entry) m; |
| // Trace.err("key: " + entry.getKey() + " ; " + entry.getValue().getClass().getName()); |
| |
| XMLizable xmlizable = delegates.contains((String) entry.getKey()); |
| if (xmlizable != null) { |
| // Trace.err("--- Delegate ALREADY defined for: " + (String) entry.getKey() |
| // + " (" + entry.getValue().getClass().getName() + ")"); |
| if (xmlizable instanceof AEDeploymentMetaData) { |
| if (entry.getValue() instanceof Import) { |
| ((AEDeploymentMetaData) xmlizable).setImportedAE((Import) entry.getValue()); |
| Trace.bug("Import should be resolved for: " + ((Import) entry.getValue()).getName()); |
| } else { |
| ((AEDeploymentMetaData) xmlizable).setResourceSpecifier((ResourceSpecifier) entry.getValue(), aResourceManager, recursive); |
| } |
| } else if (xmlizable instanceof RemoteAEDeploymentMetaData) { |
| if (entry.getValue() instanceof Import) { |
| ((RemoteAEDeploymentMetaData) xmlizable).setImportedAE((Import) entry.getValue()); |
| Trace.bug("Import should be resolved for: " + ((Import) entry.getValue()).getName()); |
| } else { |
| ((RemoteAEDeploymentMetaData) xmlizable).setResourceSpecifier((ResourceSpecifier) entry.getValue(), aResourceManager, recursive); |
| } |
| } |
| continue; |
| } |
| |
| // New delegate |
| AEDeploymentMetaData_Impl meta = new AEDeploymentMetaData_Impl(); |
| meta.setKey((String) entry.getKey()); |
| if (entry.getValue() instanceof ResourceSpecifier) { |
| meta.setResourceSpecifier((ResourceSpecifier) entry.getValue(), aResourceManager, recursive); |
| } |
| |
| // Create a new Error Config |
| Object obj = UIMAFramework.getResourceSpecifierFactory().createObject(AsyncAggregateErrorConfiguration.class); |
| if (obj != null) { |
| // Trace.err("OK to create " + cls.getName() + " for " + meta.getKey()); |
| ((AsyncAEErrorConfiguration) obj).getGetMetadataErrors().setTimeout(0); |
| meta.setAsyncAEErrorConfiguration((AsyncAEErrorConfiguration) obj); |
| } else { |
| Trace.err("CANNOT create " + AsyncAggregateErrorConfiguration.class.getName() + " for " + meta.getKey()); |
| } |
| |
| delegates.addDelegate(meta); |
| } // for |
| } |
| |
| protected void resolveDelegatesInternal(AnalysisEngineDescription aeDescription, |
| ResourceManager aResourceManager, boolean recursive) throws InvalidXMLException { |
| if (aeDescription.isPrimitive()) { |
| return; |
| } |
| if (getDelegates() == null) { |
| // Trace.err(getKey() + ": NO AEDeploymentMetaData delegates"); |
| return; |
| } |
| |
| Map mapDelegateAEs = aeDescription.getDelegateAnalysisEngineSpecifiers(aResourceManager); |
| List<XMLizable> list = getDelegates().getDelegates(); |
| for (XMLizable xmlizable : list) { |
| if (xmlizable instanceof AEDeploymentMetaData) { |
| AEDeploymentMetaData meta = (AEDeploymentMetaData) xmlizable; |
| if (mapDelegateAEs.containsKey(meta.getKey())) { |
| // Recursive |
| // Trace.err(4, "Match2: " + meta.getKey()); |
| ResourceSpecifier rs = (ResourceSpecifier) mapDelegateAEs.get(meta.getKey()); |
| meta.setResourceSpecifier(rs, aResourceManager, recursive); |
| } else { |
| // Trace.err("NOT match: " + meta.getKey()); |
| throw new DDEInvalidXMLException(DDEInvalidXMLException.DELEGATE_KEY_NOT_FOUND, new |
| Object[] {meta.getKey(), aeDescription.getSourceUrlString() }); |
| } |
| |
| } else if (xmlizable instanceof RemoteAEDeploymentMetaData) { |
| RemoteAEDeploymentMetaData meta = (RemoteAEDeploymentMetaData) xmlizable; |
| if (mapDelegateAEs.containsKey(meta.getKey())) { |
| // Trace.err(4, "match: " + meta.getKey()); |
| ResourceSpecifier rs = (ResourceSpecifier) mapDelegateAEs.get(meta.getKey()); |
| meta.setResourceSpecifier(rs, aResourceManager, recursive); |
| |
| } else { |
| Trace.err("NOT Match: " + meta.getKey()); |
| throw new DDEInvalidXMLException(DDEInvalidXMLException.DELEGATE_KEY_NOT_FOUND, new |
| Object[] {meta.getKey(), aeDescription.getSourceUrlString() }); |
| } |
| } |
| |
| } // for |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#buildFromXMLElement(org.w3c.dom.Element, |
| * org.apache.uima.util.XMLParser, org.apache.uima.util.XMLParser.ParsingOptions) |
| */ |
| |
| public void buildFromXMLElement(Element aElement, XMLParser aParser, |
| XMLParser.ParsingOptions aOptions) throws InvalidXMLException { |
| // Find out about the parent node (used to decide the type of error config |
| boolean isTopAnalysisEngine = false; |
| if (aElement.getParentNode() instanceof Element) { |
| if ( ((Element) aElement.getParentNode()).getTagName().equalsIgnoreCase(TAG_SERVICE) ) { |
| isTopAnalysisEngine = true; |
| // Trace.err(" >>> Top AE "); |
| } else { |
| // Trace.err(" >>> Delegate AE "); |
| } |
| } else { |
| Trace.bug("Not an Element class: " + aElement.getParentNode().getClass().getName()); |
| } |
| |
| // Check for "key" and "async" attributes |
| NamedNodeMap map = aElement.getAttributes(); |
| if (map != null) { |
| for (int i=0; i<map.getLength(); ++i) { |
| Node item = map.item(i); |
| String name = item.getNodeName(); |
| String val = item.getNodeValue(); |
| if (val == null) { |
| val = ""; |
| } else { |
| val = val.trim(); |
| } |
| if (AEDeploymentConstants.TAG_ATTR_KEY.equalsIgnoreCase(name)) { |
| // Set "key = ..." attribute |
| setKey(val); |
| |
| } else if (AEDeploymentConstants.TAG_ATTR_ASYNC.equalsIgnoreCase(name)) { |
| // Set "async =[yes|no]" attribute |
| setAsync(Boolean.parseBoolean(val)); |
| |
| } else if (AEDeploymentConstants.TAG_ATTR_INPUT_QUEUE_SCALEOUT.equalsIgnoreCase(name)) { |
| // Set "inputQueueScaleout =nnn" attribute |
| try { |
| int n = Integer.parseInt(val); |
| if (n > 0) { |
| setInputQueueScaleout(n); |
| } else { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[] { n, TAG_ATTR_INPUT_QUEUE_SCALEOUT }); |
| } |
| } catch (NumberFormatException e) { |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_INPUT_QUEUE_SCALEOUT }, e); |
| } |
| |
| } else if (AEDeploymentConstants.TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT.equalsIgnoreCase(name)) { |
| // Set "inputQueueScaleout =nnn" attribute |
| try { |
| int n = Integer.parseInt(val); |
| if (n > 0) { |
| setInternalReplyQueueScaleout(n); |
| } else { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[] { n, TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT }); |
| } |
| } catch (NumberFormatException e) { |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT }, e); |
| } |
| |
| } else { |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[]{name}); |
| } |
| } |
| |
| // Check validity of queue listeners |
| if (!isAsync()) { |
| if (getInputQueueScaleout() > 1) { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[] { getInputQueueScaleout(), TAG_ATTR_INPUT_QUEUE_SCALEOUT }); |
| } |
| if (getInternalReplyQueueScaleout() > 1) { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[] { getInternalReplyQueueScaleout(), TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT }); |
| } |
| } |
| } |
| |
| // Has "key = ..." attribute ? |
| if (!isTopAnalysisEngine && getKey() == null) { |
| throw new InvalidXMLException(InvalidXMLException.ELEMENT_NOT_FOUND, |
| new Object[]{AEDeploymentConstants.TAG_ATTR_KEY, AEDeploymentConstants.TAG_ANALYSIS_ENGINE}); |
| } |
| |
| NodeList childNodes = aElement.getChildNodes(); |
| String val; |
| for (int i = 0; i < childNodes.getLength(); i++) { |
| Node curNode = childNodes.item(i); |
| if (!(curNode instanceof Element)) { |
| continue; |
| } |
| Element elem = (Element) curNode; |
| |
| if (AEDeploymentConstants.TAG_SCALE_OUT.equalsIgnoreCase(elem.getTagName())) { |
| int n; |
| val = DDParserUtil.checkAndGetAttributeValue(TAG_SCALE_OUT, TAG_ATTR_NUMBER_OF_INSTANCES, elem, true); |
| if (val == null || val.trim().length() == 0) { |
| n = 0; |
| } else { |
| try { |
| n = Integer.parseInt(val); |
| } catch (NumberFormatException e) { |
| e.printStackTrace(); |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_NUMBER_OF_INSTANCES }, e); |
| } |
| } |
| setNumberOfInstances(n); |
| |
| } else if (TAG_CAS_MULTIPLIER.equalsIgnoreCase(elem.getTagName())) { |
| // Get "poolSize" attribute |
| int n; |
| val = DDParserUtil.checkAndGetAttributeValue(TAG_CAS_MULTIPLIER, TAG_ATTR_POOL_SIZE, elem, true); |
| if (val == null || val.trim().length() == 0) { |
| n = 0; |
| } else { |
| try { |
| n = Integer.parseInt(val); |
| } catch (NumberFormatException e) { |
| e.printStackTrace(); |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_POOL_SIZE }, e); |
| } |
| } |
| setCasMultiplierPoolSize(n); |
| |
| // Check for Optional "initialFsHeapSize" |
| val = DDParserUtil.checkAndGetAttributeValue(TAG_CAS_MULTIPLIER, TAG_ATTR_INIT_SIZE_OF_CAS_HEAP, elem, false); |
| if (val != null && val.trim().length() > 0) { |
| try { |
| initialFsHeapSize = Integer.parseInt(val); |
| } catch (NumberFormatException e) { |
| e.printStackTrace(); |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_INIT_SIZE_OF_CAS_HEAP }, e); |
| } |
| } |
| |
| // Check for Optional "processParentLast =[false|true]" |
| val = DDParserUtil.checkAndGetAttributeValue(TAG_CAS_MULTIPLIER, TAG_ATTR_PROCESS_PARENT_CAS_LAST, elem, false); |
| boolean b = false; |
| if (val != null && val.trim().length() > 0) { |
| try { |
| b = Boolean.parseBoolean(val); |
| } catch (NumberFormatException e) { |
| e.printStackTrace(); |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[] { TAG_ATTR_PROCESS_PARENT_CAS_LAST }, e); |
| } |
| } |
| setProcessParentCASLast(b); |
| |
| } else if (AEDeploymentConstants.TAG_DELEGATES.equalsIgnoreCase(elem.getTagName())) { |
| delegates = new AEDelegates_Impl(this); |
| NodeList nodes = elem.getChildNodes(); |
| if (nodes.getLength() > 0) { |
| // Look for "analysisEngine" or "remoteDelegate" |
| for (int k = 0; k < nodes.getLength(); ++k) { |
| Node n = nodes.item(k); |
| if (!(n instanceof Element)) { |
| continue; |
| } |
| |
| Element e = (Element) n; |
| if (AEDeploymentConstants.TAG_ANALYSIS_ENGINE.equalsIgnoreCase(e.getTagName())) { |
| // Add "Analysis Engine" to the list |
| delegates.addDelegate((DeploymentMetaData_Impl) aParser.buildObject(e, aOptions)); |
| |
| } else if (AEDeploymentConstants.TAG_REMOTE_DELEGATE.equalsIgnoreCase(e.getTagName())) { |
| delegates.addDelegate((DeploymentMetaData_Impl) aParser.buildObject(e, aOptions)); |
| |
| } |
| } |
| } |
| } else if (AEDeploymentConstants.TAG_ASYNC_PRIMITIVE_ERROR_CONFIGURATION.equalsIgnoreCase(elem |
| .getTagName())) { |
| asyncAEErrorConfiguration = (AsyncPrimitiveErrorConfiguration) aParser.buildObject(elem, |
| aOptions); |
| asyncAEErrorConfiguration.sParentObject(this); |
| |
| } else if (AEDeploymentConstants.TAG_ASYNC_AGGREGATE_ERROR_CONFIGURATION.equalsIgnoreCase(elem |
| .getTagName())) { |
| asyncAEErrorConfiguration = (AsyncAggregateErrorConfiguration) aParser.buildObject(elem, |
| aOptions); |
| asyncAEErrorConfiguration.sParentObject(this); |
| |
| } else { |
| throw new InvalidXMLException(InvalidXMLException.UNKNOWN_ELEMENT, |
| new Object[]{elem.getTagName()}); |
| } |
| |
| } // for |
| |
| // Check if async=false and "delegates" are defined |
| if ( (!isAsync()) && delegates != null) { |
| setAsync(true); |
| } |
| |
| // Create Error Config if not specified |
| if (asyncAEErrorConfiguration == null) { |
| Class cls; |
| if (isTopAnalysisEngine) { |
| cls = AsyncPrimitiveErrorConfiguration.class; |
| } else { |
| cls = AsyncAggregateErrorConfiguration.class; |
| } |
| asyncAEErrorConfiguration = (AsyncAEErrorConfiguration) UIMAFramework |
| .getResourceSpecifierFactory().createObject(cls); |
| setAsyncAEErrorConfiguration(asyncAEErrorConfiguration); |
| asyncAEErrorConfiguration.sParentObject(this); |
| if (cls == AsyncAggregateErrorConfiguration.class) { |
| asyncAEErrorConfiguration.getGetMetadataErrors().setTimeout(0); |
| } |
| } else { |
| // Validate some values |
| if (!isTopAnalysisEngine) { |
| int value; |
| String s; |
| boolean b; |
| if (!isAsync()) { |
| // For co-located delegates |
| // Check for GetMetadataErrors |
| if ( (value=asyncAEErrorConfiguration.getGetMetadataErrors().getMaxRetries()) != 0) { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[]{value, TAG_ATTR_MAX_RETRIES}); |
| // } else if ( (value=asyncAEErrorConfiguration.getGetMetadataErrors().getTimeout()) != 0) { |
| // throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| // new Object[]{value, TAG_ATTR_TIMEOUT}); |
| // } else if ( !(s=asyncAEErrorConfiguration.getGetMetadataErrors().getErrorAction()).equals("terminate")) { |
| // throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| // new Object[]{s, TAG_ATTR_ERROR_ACTION}); |
| } |
| |
| // Check for ProcessCasErrors |
| if ( (value=asyncAEErrorConfiguration.getProcessCasErrors().getMaxRetries()) != 0) { |
| throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| new Object[]{value, TAG_ATTR_MAX_RETRIES}); |
| // } else if ( (b=asyncAEErrorConfiguration.getProcessCasErrors().isContinueOnRetryFailure()) ) { |
| // throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| // new Object[]{b, TAG_ATTR_CONTINUE_ON_RETRY_FAILURE}); |
| } |
| } |
| |
| // Check for Threshold Count = 0 |
| // if ( asyncAEErrorConfiguration.getProcessCasErrors().getThresholdCount() == 0) { |
| // if ( (value=asyncAEErrorConfiguration.getProcessCasErrors().getThresholdWindow()) != 0 ) { |
| // throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| // new Object[]{value, TAG_ATTR_THRESHOLD_WINDOW}); |
| // } |
| // if ( !(s=asyncAEErrorConfiguration.getProcessCasErrors().getThresholdAction()).equals("disable")) { |
| // throw new InvalidXMLException(InvalidXMLException.INVALID_ELEMENT_TEXT, |
| // new Object[]{s, TAG_ATTR_THRESHOLD_ACTION}); |
| // } |
| // } |
| } |
| |
| } |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#toXML(org.xml.sax.ContentHandler, |
| * boolean) |
| */ |
| public void toXML(ContentHandler aContentHandler, boolean aWriteDefaultNamespaceAttribute) |
| throws SAXException { |
| // <TAG_ANALYSIS_ENGINE key= async= > |
| AttributesImpl attrs = new AttributesImpl(); |
| if (!isTopAnalysisEngine() && getKey() != null && getKey().trim().length() > 0) { |
| attrs.addAttribute("", AEDeploymentConstants.TAG_ATTR_KEY, |
| AEDeploymentConstants.TAG_ATTR_KEY, null, getKey()); |
| } |
| // if (issetAsync) { |
| attrs.addAttribute("", AEDeploymentConstants.TAG_ATTR_ASYNC, |
| AEDeploymentConstants.TAG_ATTR_ASYNC, null, Boolean.toString(isAsync())); |
| // } |
| if (inputQueueScaleout > 0) { |
| attrs.addAttribute("", AEDeploymentConstants.TAG_ATTR_INPUT_QUEUE_SCALEOUT, |
| AEDeploymentConstants.TAG_ATTR_INPUT_QUEUE_SCALEOUT, null, |
| "" + inputQueueScaleout); |
| } |
| if (internalReplyQueueScaleout > 0) { |
| attrs.addAttribute("", AEDeploymentConstants.TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT, |
| AEDeploymentConstants.TAG_ATTR_INTERNAL_REPLYQUEUE_SCALEOUT, null, |
| "" + internalReplyQueueScaleout); |
| } |
| aContentHandler.startElement("", AEDeploymentConstants.TAG_ANALYSIS_ENGINE, |
| AEDeploymentConstants.TAG_ANALYSIS_ENGINE, attrs); |
| attrs.clear(); |
| |
| // <scaleout numberOfInstances="1"/> <!-- optional --> |
| if (getNumberOfInstances() != UNDEFINED_INT) { |
| attrs |
| .addAttribute("", AEDeploymentConstants.TAG_ATTR_NUMBER_OF_INSTANCES, |
| AEDeploymentConstants.TAG_ATTR_NUMBER_OF_INSTANCES, null, "" |
| + getNumberOfInstances()); |
| aContentHandler.startElement("", AEDeploymentConstants.TAG_SCALE_OUT, |
| AEDeploymentConstants.TAG_SCALE_OUT, attrs); |
| aContentHandler.endElement("", "", AEDeploymentConstants.TAG_SCALE_OUT); |
| attrs.clear(); |
| } |
| |
| // <casMultiplier poolSize="5" processParentLast="false"initialFsHeapSize="200000" /> <!-- req | omit--> |
| // Only for AS primitive CAS Multiplier |
| if (!isAsync() && AEDeploymentDescription_Impl.isCASMultiplier(getResourceSpecifier())) { |
| if (getCasMultiplierPoolSize() != UNDEFINED_INT) { |
| attrs.addAttribute("", AEDeploymentConstants.TAG_ATTR_POOL_SIZE, |
| AEDeploymentConstants.TAG_ATTR_POOL_SIZE, null, "" + getCasMultiplierPoolSize()); |
| attrs.addAttribute("", TAG_ATTR_INIT_SIZE_OF_CAS_HEAP, TAG_ATTR_INIT_SIZE_OF_CAS_HEAP, |
| null, ""+initialFsHeapSize); |
| |
| attrs.addAttribute("", TAG_ATTR_PROCESS_PARENT_CAS_LAST, TAG_ATTR_PROCESS_PARENT_CAS_LAST, |
| null, ""+getProcessParentCASLast()); |
| |
| aContentHandler.startElement("", AEDeploymentConstants.TAG_CAS_MULTIPLIER, |
| AEDeploymentConstants.TAG_CAS_MULTIPLIER, attrs); |
| aContentHandler.endElement("", "", AEDeploymentConstants.TAG_CAS_MULTIPLIER); |
| attrs.clear(); |
| } |
| } |
| // -------------- <delegates> --------------- |
| if (isAsync() && delegates != null) { |
| aContentHandler.startElement("", AEDeploymentConstants.TAG_DELEGATES, |
| AEDeploymentConstants.TAG_DELEGATES, attrs); |
| for (XMLizable x : delegates.getDelegates()) { |
| if (x instanceof AEDeploymentMetaData_Impl) { |
| org.apache.uima.aae.deployment.AEDeploymentMetaData aeDepl = (org.apache.uima.aae.deployment.AEDeploymentMetaData) x; |
| aeDepl.toXML(aContentHandler, aWriteDefaultNamespaceAttribute); |
| |
| } else if (x instanceof RemoteAEDeploymentMetaData_Impl) { |
| RemoteAEDeploymentMetaData_Impl aeDepl = (RemoteAEDeploymentMetaData_Impl) x; |
| aeDepl.toXML(aContentHandler, aWriteDefaultNamespaceAttribute); |
| } else { |
| } |
| } |
| aContentHandler.endElement("", "", AEDeploymentConstants.TAG_DELEGATES); |
| } |
| // -------------- </delegates> --------------- |
| |
| // <asyncAggregateErrorConfiguration .../> <!-- optional --> |
| if (asyncAEErrorConfiguration != null) { |
| asyncAEErrorConfiguration.toXML(aContentHandler, aWriteDefaultNamespaceAttribute); |
| } else { |
| Trace.err(getKey() + ": asyncAEErrorConfiguration == null"); |
| } |
| |
| // </TAG_ANALYSIS_ENGINE> |
| aContentHandler.endElement("", "", AEDeploymentConstants.TAG_ANALYSIS_ENGINE); |
| } |
| |
| protected XmlizationInfo getXmlizationInfo() { |
| // return XMLIZATION_INFO; |
| return new XmlizationInfo(null, null); |
| // this object has custom XMLization routines |
| } |
| |
| static final private XmlizationInfo XMLIZATION_INFO = new XmlizationInfo( |
| AEDeploymentConstants.TAG_ANALYSIS_ENGINE, new PropertyXmlInfo[] { |
| new PropertyXmlInfo("cpeDescriptor", false), |
| new PropertyXmlInfo("defaultCasProcessorSettings", false) }); |
| |
| /** ********************************************************************** */ |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#getNumberOfInstances() |
| */ |
| public int getNumberOfInstances() { |
| return numberOfInstances; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#setNumberOfInstances(int) |
| */ |
| public void setNumberOfInstances(int numberOfInstances) { |
| this.numberOfInstances = numberOfInstances; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#getCasMultiplierPoolSize() |
| */ |
| public int getCasMultiplierPoolSize() { |
| return casMultiplierPoolSize; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#setCasMultiplierPoolSize(int) |
| */ |
| public void setCasMultiplierPoolSize(int poolSize) { |
| this.casMultiplierPoolSize = poolSize; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#getDelegates() |
| */ |
| public AEDelegates_Impl getDelegates() { |
| return delegates; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uima.aae.deployment.impl.AEDeploymentMetaData#setDelegates(java.util.List) |
| */ |
| public void setDelegates(AEDelegates_Impl delegates) { |
| this.delegates = delegates; |
| } |
| |
| /** |
| * @param async |
| * the async to set |
| */ |
| public void setAsync(boolean async) { |
| issetAsync = true; |
| this.async = async; |
| if (!async) { |
| inputQueueScaleout = -1; // undefined |
| internalReplyQueueScaleout = -1; // undefined |
| } |
| } |
| |
| public boolean getProcessParentCASLast() { |
| return processParentCASLast; |
| } |
| |
| public void setProcessParentCASLast(boolean value) { |
| this.processParentCASLast = value; |
| } |
| |
| /** |
| * @return the async |
| */ |
| public boolean isAsync() { |
| return async; |
| } |
| |
| /** |
| * @return the asyncPrimitiveErrorConfiguration |
| */ |
| public AsyncAEErrorConfiguration getAsyncAEErrorConfiguration() { |
| return asyncAEErrorConfiguration; |
| } |
| |
| /** |
| * @param asyncAEErrorConfiguration |
| * the asyncPrimitiveErrorConfiguration to set |
| */ |
| public void setAsyncAEErrorConfiguration(AsyncAEErrorConfiguration asyncAEErrorConfiguration) { |
| this.asyncAEErrorConfiguration = asyncAEErrorConfiguration; |
| asyncAEErrorConfiguration.sParentObject(this); |
| } |
| |
| /** |
| * @return the topAnalysisEngine |
| */ |
| public boolean isTopAnalysisEngine() { |
| return topAnalysisEngine; |
| } |
| |
| /** |
| * @param topAnalysisEngine |
| * the topAnalysisEngine to set |
| */ |
| public void setTopAnalysisEngine(boolean topAnalysisEngine) { |
| if (topAnalysisEngine) { |
| setKey("Top Analysis Engine"); |
| } |
| this.topAnalysisEngine = topAnalysisEngine; |
| } |
| |
| public Map getDelegateDeployments() { |
| // Resolve delegates |
| |
| return null; |
| } |
| |
| /** |
| * @return the importedAE |
| */ |
| public Import getImportedAE() { |
| return importedAE; |
| } |
| |
| /** |
| * @param importedAE the importedAE to set |
| */ |
| public void setImportedAE(Import importedAE) { |
| this.importedAE = importedAE; |
| } |
| |
| public boolean isCasMultiplier() { |
| return casMultiplier; |
| } |
| |
| public void setCasMultiplier(boolean casMultiplier) { |
| this.casMultiplier = casMultiplier; |
| } |
| |
| public int getInitialFsHeapSize() { |
| return initialFsHeapSize; |
| } |
| |
| public void setInitialFsHeapSize(int initialFsHeapSize) { |
| this.initialFsHeapSize = initialFsHeapSize; |
| } |
| |
| public int getInputQueueScaleout() { |
| return inputQueueScaleout; |
| } |
| |
| public int getInternalReplyQueueScaleout() { |
| return internalReplyQueueScaleout; |
| } |
| |
| public void setInputQueueScaleout(int numberOfListeners) { |
| inputQueueScaleout = numberOfListeners; |
| } |
| |
| public void setInternalReplyQueueScaleout(int numberOfListeners) { |
| internalReplyQueueScaleout = numberOfListeners; |
| } |
| |
| /** ********************************************************************** */ |
| |
| } |
