You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ode.apache.org by mr...@apache.org on 2008/08/05 01:54:05 UTC
svn commit: r682542 [2/4] - in /ode/branches/rtver:
axis2/src/main/java/org/apache/ode/axis2/
bpel-api/src/main/java/org/apache/ode/bpel/rapi/
bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/
bpel-compiler/src/main/java/org/apache/ode/bpel/com...
Added: ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/BpelCompilerImpl.java
URL: http://svn.apache.org/viewvc/ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/BpelCompilerImpl.java?rev=682542&view=auto
==============================================================================
--- ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/BpelCompilerImpl.java (added)
+++ ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/BpelCompilerImpl.java Mon Aug 4 16:54:02 2008
@@ -0,0 +1,1764 @@
+/*
+ * 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.ode.bpel.compiler.v2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+
+import javax.wsdl.Definition;
+import javax.wsdl.Message;
+import javax.wsdl.Operation;
+import javax.wsdl.Part;
+import javax.wsdl.PortType;
+import javax.wsdl.WSDLException;
+import javax.wsdl.xml.WSDLReader;
+import javax.xml.namespace.QName;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.ode.bpel.compiler.api.CompilationException;
+import org.apache.ode.bpel.compiler.api.CompilationMessage;
+import org.apache.ode.bpel.compiler.api.CompileListener;
+import org.apache.ode.bpel.compiler.v2.CompilerContext;
+import org.apache.ode.bpel.compiler.v2.ExpressionCompiler;
+import org.apache.ode.bpel.compiler.v2.ExtensionValidator;
+import org.apache.ode.bpel.compiler.bom.Activity;
+import org.apache.ode.bpel.compiler.bom.Bpel11QNames;
+import org.apache.ode.bpel.compiler.bom.Bpel20QNames;
+import org.apache.ode.bpel.compiler.bom.BpelObject;
+import org.apache.ode.bpel.compiler.bom.Catch;
+import org.apache.ode.bpel.compiler.bom.CompensationHandler;
+import org.apache.ode.bpel.compiler.bom.Correlation;
+import org.apache.ode.bpel.compiler.bom.CorrelationSet;
+import org.apache.ode.bpel.compiler.bom.Expression;
+import org.apache.ode.bpel.compiler.bom.Expression11;
+import org.apache.ode.bpel.compiler.bom.Extension;
+import org.apache.ode.bpel.compiler.bom.FaultHandler;
+import org.apache.ode.bpel.compiler.bom.Import;
+import org.apache.ode.bpel.compiler.bom.LinkSource;
+import org.apache.ode.bpel.compiler.bom.LinkTarget;
+import org.apache.ode.bpel.compiler.bom.OnAlarm;
+import org.apache.ode.bpel.compiler.bom.OnEvent;
+import org.apache.ode.bpel.compiler.bom.PartnerLink;
+import org.apache.ode.bpel.compiler.bom.PartnerLinkType;
+import org.apache.ode.bpel.compiler.bom.Process;
+import org.apache.ode.bpel.compiler.bom.Property;
+import org.apache.ode.bpel.compiler.bom.PropertyAlias;
+import org.apache.ode.bpel.compiler.bom.Scope;
+import org.apache.ode.bpel.compiler.bom.ScopeActivity;
+import org.apache.ode.bpel.compiler.bom.ScopeLikeActivity;
+import org.apache.ode.bpel.compiler.bom.TerminationHandler;
+import org.apache.ode.bpel.compiler.bom.Variable;
+import org.apache.ode.bpel.compiler.wsdl.Definition4BPEL;
+import org.apache.ode.bpel.compiler.wsdl.WSDLFactory4BPEL;
+import org.apache.ode.bpel.compiler.*;
+import org.apache.ode.bpel.rtrep.v2.DebugInfo;
+import org.apache.ode.bpel.rtrep.v2.OActivity;
+import org.apache.ode.bpel.rtrep.v2.OAssign;
+import org.apache.ode.bpel.rtrep.v2.OCatch;
+import org.apache.ode.bpel.rtrep.v2.OCompensate;
+import org.apache.ode.bpel.rtrep.v2.OCompensationHandler;
+import org.apache.ode.bpel.rtrep.v2.OConstantExpression;
+import org.apache.ode.bpel.rtrep.v2.OConstantVarType;
+import org.apache.ode.bpel.rtrep.v2.OElementVarType;
+import org.apache.ode.bpel.rtrep.v2.OEventHandler;
+import org.apache.ode.bpel.rtrep.v2.OExpression;
+import org.apache.ode.bpel.rtrep.v2.OExpressionLanguage;
+import org.apache.ode.bpel.rtrep.v2.OExtVar;
+import org.apache.ode.bpel.rtrep.v2.OFaultHandler;
+import org.apache.ode.bpel.rtrep.v2.OFlow;
+import org.apache.ode.bpel.rtrep.v2.OLValueExpression;
+import org.apache.ode.bpel.rtrep.v2.OLink;
+import org.apache.ode.bpel.rtrep.v2.OMessageVarType;
+import org.apache.ode.bpel.rtrep.v2.OPartnerLink;
+import org.apache.ode.bpel.rtrep.v2.OProcess;
+import org.apache.ode.bpel.rtrep.v2.ORethrow;
+import org.apache.ode.bpel.rtrep.v2.OScope;
+import org.apache.ode.bpel.rtrep.v2.OSequence;
+import org.apache.ode.bpel.rtrep.v2.OTerminationHandler;
+import org.apache.ode.bpel.rtrep.v2.OVarType;
+import org.apache.ode.bpel.rtrep.v2.OXsdTypeVarType;
+import org.apache.ode.bpel.rtrep.v2.OXslSheet;
+import org.apache.ode.utils.GUID;
+import org.apache.ode.utils.NSContext;
+import org.apache.ode.utils.StreamUtils;
+import org.apache.ode.utils.fs.FileUtils;
+import org.apache.ode.utils.msg.MessageBundle;
+import org.apache.ode.utils.stl.CollectionsX;
+import org.apache.ode.utils.stl.MemberOfFunction;
+import org.apache.ode.utils.stl.UnaryFunction;
+import org.apache.ode.utils.xsd.XSUtils;
+import org.apache.ode.utils.xsd.XsdException;
+import org.apache.ode.utils.xsd.SchemaModel;
+import org.apache.xerces.xni.parser.XMLEntityResolver;
+import org.w3c.dom.Node;
+
+/**
+ * Compiler for converting BPEL process descriptions (and their associated WSDL and XSD documents) into compiled representations
+ * suitable for execution by the ODE BPEL Service Provider. TODO: Move process validation into this class.
+ */
+abstract class BpelCompilerImpl extends BaseCompiler implements CompilerContext, BpelCompiler {
+ /** Class-severity logger. */
+ protected static final Log __log = LogFactory.getLog(BpelCompilerImpl.class);
+
+ /** Standardized compiler messages. */
+ private static final CommonCompilationMessages __cmsgs = MessageBundle.getMessages(CommonCompilationMessages.class);
+
+ private org.apache.ode.bpel.compiler.bom.Process _processDef;
+
+ private Date _generatedDate;
+
+ private HashMap<Class, ActivityGenerator> _actGenerators = new HashMap<Class, ActivityGenerator>();
+
+ private boolean _supressJoinFailure = false;
+
+ /** Are we currently in an atomic scope context? */
+ private boolean _atomicScope = false;
+
+ /** Are we currently compiling an isolated scope context. */
+ private boolean _isolatedScope = false;
+
+ /** Syntactic scope stack. */
+ private StructureStack _structureStack = new StructureStack();
+
+ /** Fault/compensate recovery stack. */
+ private Stack<OScope> _recoveryContextStack = new Stack<OScope>();
+
+ /** History of compiled activities */
+ private List<OActivity> _compiledActivities = new ArrayList<OActivity>();
+
+ private ResourceFinder _resourceFinder;
+
+ private WSDLRegistry _wsdlRegistry;
+
+ private final List<CompilationMessage> _errors = new ArrayList<CompilationMessage>();
+
+ private CompileListener _compileListener;
+
+ private final HashMap<String, ExpressionCompiler> _expLanguageCompilers = new HashMap<String, ExpressionCompiler>();
+
+ private final HashMap<String, OExpressionLanguage> _expLanguages = new HashMap<String, OExpressionLanguage>();
+
+ private final Set<String> _declaredExtensionNS = new HashSet<String>();
+
+ private WSDLFactory4BPEL _wsdlFactory;
+
+ private OExpressionLanguage _konstExprLang;
+
+ private Map<QName, Node> _customProcessProperties;
+
+ private URI _processURI;
+
+ private Map<QName, ExtensionValidator> _extensionValidators = new HashMap<QName, ExtensionValidator>();
+
+ BpelCompilerImpl(WSDLFactory4BPEL wsdlFactory) {
+ _wsdlFactory = wsdlFactory;
+ _wsdlRegistry = new WSDLRegistry(this);
+ }
+
+ public void addWsdlImport(URI from, URI wsdlImport, SourceLocation sloc) {
+ Definition4BPEL def;
+ try {
+ WSDLReader r = _wsdlFactory.newWSDLReader();
+ WSDLLocatorImpl locator = new WSDLLocatorImpl(_resourceFinder, from.resolve(wsdlImport));
+ def = (Definition4BPEL) r.readWSDL(locator);
+ } catch (WSDLException e) {
+ recoveredFromError(sloc, new CompilationException(__cmsgs.errWsdlParseError(e.getFaultCode(), e.getLocation(), e
+ .getMessage())));
+ throw new CompilationException(__cmsgs.errWsdlImportFailed(wsdlImport.toASCIIString(), e.getFaultCode())
+ .setSource(sloc), e);
+ }
+
+ try {
+ _wsdlRegistry.addDefinition(def, _resourceFinder, from.resolve(wsdlImport));
+ if (__log.isDebugEnabled())
+ __log.debug("Added WSDL Definition: " + wsdlImport);
+ } catch (CompilationException ce) {
+ recoveredFromError(sloc, ce);
+ }
+ }
+
+ public void addXsdImport(URI from, URI location, SourceLocation sloc) {
+ URI resFrom = from.resolve(location);
+ if (__log.isDebugEnabled())
+ __log.debug("Adding XSD import from " + resFrom + " location " + location);
+ XMLEntityResolver resolver = new WsdlFinderXMLEntityResolver(_resourceFinder, location, new HashMap<URI, String>(), true);
+ try {
+ Map<URI, byte[]> schemas = XSUtils.captureSchema(resFrom.toString(), resolver);
+ InputStream xsdStream = _resourceFinder.openResource(resFrom);
+ byte[] data;
+ try {
+ data = StreamUtils.read(xsdStream);
+ } finally {
+ xsdStream.close();
+ }
+ schemas.put(resFrom, data);
+ _wsdlRegistry.addSchemas(schemas);
+ } catch (XsdException e) {
+ CompilationException ce = new CompilationException(__cmsgs.errInvalidImport(location.toString()));
+ recoveredFromError(sloc, ce);
+ } catch (MalformedURLException e) {
+ CompilationException ce = new CompilationException(__cmsgs.errInvalidImport(location.toString()));
+ recoveredFromError(sloc, ce);
+ } catch (IOException e) {
+ CompilationException ce = new CompilationException(__cmsgs.errInvalidImport(location.toString()));
+ recoveredFromError(sloc, ce);
+ }
+ }
+
+ public void setResourceFinder(ResourceFinder finder) {
+ if (finder == null) {
+ _resourceFinder = new DefaultResourceFinder();
+ } else {
+ _resourceFinder = finder;
+ }
+
+ }
+
+ public void setCompileListener(CompileListener compileListener) {
+ _compileListener = compileListener;
+ }
+
+ public CompileListener getCompileListener() {
+ return _compileListener;
+ }
+
+ public void setCustomProperties(Map<QName, Node> customProperties) {
+ _customProcessProperties = customProperties;
+ }
+
+ /**
+ * Get the process definition.
+ *
+ * @return the process definition
+ */
+ public Process getProcessDef() {
+ return _processDef;
+ }
+
+ public PortType resolvePortType(final QName portTypeName) {
+ if (portTypeName == null)
+ throw new NullPointerException("Null portTypeName argument!");
+
+ PortType portType = _wsdlRegistry.getPortType(portTypeName);
+ if (portType == null)
+ throw new CompilationException(__cmsgs.errUndeclaredPortType(portTypeName));
+ return portType;
+ }
+
+ public OLink resolveLink(String linkName) {
+ OLink ret = null;
+
+ // Fist find where the link is declared.
+ for (Iterator<OActivity> i = _structureStack.iterator(); i.hasNext();) {
+ OActivity oact = i.next();
+ if (oact instanceof OFlow)
+ ret = ((OFlow) oact).getLocalLink(linkName);
+ if (ret != null)
+ return ret;
+ }
+
+ throw new CompilationException(__cmsgs.errUndeclaredLink(linkName));
+ }
+
+ public OScope.Variable resolveVariable(String varName) {
+ for (Iterator<OScope> i = _structureStack.oscopeIterator(); i.hasNext();) {
+ OScope.Variable var = i.next().getLocalVariable(varName);
+ if (var != null)
+ return var;
+ }
+ // A "real" variable couldn't be found, checking if we're dealing with a
+ // process custom property
+ if (_customProcessProperties != null && _customProcessProperties.get(varName) != null) {
+
+ }
+ throw new CompilationException(__cmsgs.errUndeclaredVariable(varName));
+ }
+
+ public List<OScope.Variable> getAccessibleVariables() {
+ ArrayList<OScope.Variable> result = new ArrayList<OScope.Variable>();
+ for (Iterator<OScope> i = _structureStack.oscopeIterator(); i.hasNext();) {
+ result.addAll(i.next().variables.values());
+ }
+ return result;
+ }
+
+ public OScope.Variable resolveMessageVariable(String inputVar) throws CompilationException {
+ OScope.Variable var = resolveVariable(inputVar);
+ if (!(var.type instanceof OMessageVarType))
+ throw new CompilationException(__cmsgs.errMessageVariableRequired(inputVar));
+ return var;
+ }
+
+ public OScope.Variable resolveMessageVariable(String inputVar, QName messageType) throws CompilationException {
+ OScope.Variable var = resolveMessageVariable(inputVar);
+ if (!((OMessageVarType) var.type).messageType.equals(messageType))
+ throw new CompilationException(__cmsgs.errVariableTypeMismatch(var.name, messageType,
+ ((OMessageVarType) var.type).messageType));
+ return var;
+ }
+
+ public OProcess.OProperty resolveProperty(QName name) {
+
+ for (OProcess.OProperty prop : _oprocess.properties) {
+ if (prop.name.equals(name))
+ return prop;
+ }
+ throw new CompilationException(__cmsgs.errUndeclaredProperty(name));
+ }
+
+ public OProcess.OPropertyAlias resolvePropertyAlias(OScope.Variable variable, QName propertyName) {
+ if (!(variable.type instanceof OMessageVarType))
+ throw new CompilationException(__cmsgs.errMessageVariableRequired(variable.name));
+
+ OProcess.OProperty property = resolveProperty(propertyName);
+ OProcess.OPropertyAlias alias = property.getAlias(variable.type);
+ if (alias == null)
+ throw new CompilationException(__cmsgs.errUndeclaredPropertyAlias(variable.type.toString(), propertyName));
+
+ return alias;
+ }
+
+ public OScope resolveCompensatableScope(final String scopeToCompensate) throws CompilationException {
+ if (_recoveryContextStack.isEmpty())
+ throw new CompilationException(__cmsgs.errCompensateNAtoContext());
+ OScope recoveryContext = _recoveryContextStack.peek();
+
+ OScope scopeToComp = CollectionsX.find_if(recoveryContext.compensatable, new MemberOfFunction<OScope>() {
+ public boolean isMember(OScope o) {
+ return o.name != null && o.name.equals(scopeToCompensate);
+ }
+ });
+ if (scopeToComp == null)
+ throw new CompilationException(__cmsgs.errCompensateOfInvalidScope(scopeToCompensate));
+
+ return scopeToComp;
+ }
+
+ public String getSourceLocation() {
+ return _processDef.getSource() == null ? null : _processDef.getSource();
+ }
+
+ public OScope.CorrelationSet resolveCorrelationSet(String csetName) {
+ for (Iterator<OScope> i = _structureStack.oscopeIterator(); i.hasNext();) {
+ OScope.CorrelationSet cset = i.next().getCorrelationSet(csetName);
+ if (cset != null)
+ return cset;
+ }
+
+ throw new CompilationException(__cmsgs.errUndeclaredCorrelationSet(csetName));
+ }
+
+ @SuppressWarnings("unchecked")
+ public OMessageVarType resolveMessageType(QName messageType) {
+ OMessageVarType msgType = _oprocess.messageTypes.get(messageType);
+ if (msgType == null) {
+ Message msg = _wsdlRegistry.getMessage(messageType);
+ if (msg == null) {
+ throw new CompilationException(__cmsgs.errUndeclaredMessage(messageType.getLocalPart(), messageType
+ .getNamespaceURI()));
+ }
+
+ List<OMessageVarType.Part> parts = new ArrayList<OMessageVarType.Part>();
+ CollectionsX.transform(parts, ((List<Part>) msg.getOrderedParts(null)),
+ new UnaryFunction<Part, OMessageVarType.Part>() {
+ public OMessageVarType.Part apply(Part part) {
+ OVarType partType;
+ if (part.getElementName() != null) {
+ partType = resolveElementType(part.getElementName());
+ } else {
+ partType = resolveXsdType(part.getTypeName());
+ }
+
+ OMessageVarType.Part opart = new OMessageVarType.Part(_oprocess, part.getName(), partType);
+ opart.debugInfo = createDebugInfo(_processDef, "Message Variable Part: " + part.getName());
+ return opart;
+ }
+ });
+ msgType = new OMessageVarType(_oprocess, msg.getQName(), parts);
+ msgType.debugInfo = createDebugInfo(_processDef, "Message Type: " + msg.getQName());
+ _oprocess.messageTypes.put(msg.getQName(), msgType);
+ }
+ return msgType;
+ }
+
+ public OXsdTypeVarType resolveXsdType(QName typeName) throws CompilationException {
+ OXsdTypeVarType type = _oprocess.xsdTypes.get(typeName);
+ if (type == null) {
+ SchemaModel model = null;
+ try {
+ model = _wsdlRegistry.getSchemaModel();
+ } catch (IllegalArgumentException iaa) { }
+ if (model == null || !model.knowsSchemaType(typeName))
+ throw new CompilationException(__cmsgs.errUndeclaredXsdType(typeName));
+
+ type = new OXsdTypeVarType(_oprocess);
+ type.debugInfo = createDebugInfo(_processDef, "XSD Type: " + typeName);
+ type.xsdType = typeName;
+ type.simple = _wsdlRegistry.getSchemaModel().isSimpleType(typeName);
+ _oprocess.xsdTypes.put(typeName, type);
+ }
+
+ return type;
+ }
+
+ public OMessageVarType.Part resolvePart(OScope.Variable var, String partname) {
+ if (!(var.type instanceof OMessageVarType))
+ throw new CompilationException(__cmsgs.errMessageVariableRequired(var.name));
+ OMessageVarType msgVarType = (OMessageVarType) var.type;
+ OMessageVarType.Part part = msgVarType.parts.get(partname);
+ if (part == null)
+ throw new CompilationException(__cmsgs.errUndeclaredMessagePart(var.name, ((OMessageVarType) var.type).messageType,
+ partname));
+ return part;
+ }
+
+ public OMessageVarType.Part resolveHeaderPart(OScope.Variable var, String partname) {
+ if (!(var.type instanceof OMessageVarType))
+ throw new CompilationException(__cmsgs.errMessageVariableRequired(var.name));
+ OMessageVarType msgVarType = (OMessageVarType) var.type;
+ return msgVarType.parts.get(partname);
+ }
+
+ public PartnerLinkType resolvePartnerLinkType(QName partnerLinkType) {
+
+ PartnerLinkType plinkType = _wsdlRegistry.getPartnerLinkType(partnerLinkType);
+ if (plinkType == null)
+ throw new CompilationException(__cmsgs.errUndeclaredPartnerLinkType(partnerLinkType));
+ return plinkType;
+ }
+
+ public OPartnerLink resolvePartnerLink(String name) {
+ for (Iterator<OScope> i = _structureStack.oscopeIterator(); i.hasNext();) {
+ OPartnerLink oplink = i.next().getLocalPartnerLink(name);
+ if (oplink != null)
+ return oplink;
+ }
+
+ throw new CompilationException(__cmsgs.errUndeclaredPartnerLink(name));
+ }
+
+ @SuppressWarnings("unchecked")
+ public Operation resolvePartnerRoleOperation(final OPartnerLink partnerLink, final String operationName) {
+ if (partnerLink.partnerRolePortType == null) {
+ throw new CompilationException(__cmsgs.errPartnerLinkDoesNotDeclarePartnerRole(partnerLink.getName()));
+ }
+
+ Operation found = CollectionsX.find_if((List<Operation>) partnerLink.partnerRolePortType.getOperations(),
+ new MemberOfFunction<Operation>() {
+ public boolean isMember(Operation o) {
+ // Guard against WSDL4j funny business.
+ if ((o.getInput() == null || o.getInput().getMessage() == null)
+ && (o.getOutput() == null || o.getOutput().getMessage() == null)) {
+ return false;
+ }
+ return o.getName().equals(operationName);
+ }
+ });
+
+ if (found == null)
+ throw new CompilationException(__cmsgs
+ .errUndeclaredOperation(partnerLink.partnerRolePortType.getQName(), operationName));
+ return found;
+ }
+
+ @SuppressWarnings("unchecked")
+ public Operation resolveMyRoleOperation(final OPartnerLink partnerLink, final String operationName) {
+ if (partnerLink.myRolePortType == null) {
+ throw new CompilationException(__cmsgs.errPartnerLinkDoesNotDeclareMyRole(partnerLink.getName()));
+ }
+
+ Operation found = CollectionsX.find_if((List<Operation>) partnerLink.myRolePortType.getOperations(),
+ new MemberOfFunction<Operation>() {
+ public boolean isMember(Operation o) {
+ // Again, guard against WSDL4J's "help"
+ if ((o.getInput() == null || o.getInput().getMessage() == null)
+ && (o.getOutput() == null || o.getOutput().getMessage() == null))
+ return false;
+ return o.getName().equals(operationName);
+ }
+ });
+ if (found == null) {
+ throw new CompilationException(__cmsgs.errUndeclaredOperation(partnerLink.myRolePortType.getQName(), operationName));
+ }
+ return found;
+ }
+
+ /**
+ * Produce a boolean {@link OExpression} expression that returns a constant value.
+ *
+ * @param value
+ * constant value to return
+ * @return {@link OExpression} returning a constant value.
+ */
+ public OExpression constantExpr(boolean value) {
+ OConstantExpression ce = new OConstantExpression(_oprocess, value ? Boolean.TRUE : Boolean.FALSE);
+ ce.debugInfo = createDebugInfo(_processDef, "Constant Boolean Expression: " + value);
+ ce.expressionLanguage = _konstExprLang;
+ return ce;
+ }
+
+ public OLValueExpression compileLValueExpr(Expression expression) throws CompilationException {
+ return (OLValueExpression) compileExpr(expression, false, true);
+ }
+
+ public OExpression compileJoinCondition(Expression expression) throws CompilationException {
+ return compileExpr(expression, true, false);
+ }
+
+ public OExpression compileExpr(Expression expression) throws CompilationException {
+ return compileExpr(expression, false, false);
+ }
+
+ public OExpression compileExpr(String expr, NSContext nc) {
+ // Does this really work?
+ BpelObject cur = _structureStack.topSource();
+ return compileExpr(new Expression11(cur.getElement(), cur.getElement().getOwnerDocument().createTextNode(expr)), false,
+ false);
+ }
+
+ private OExpression compileExpr(Expression expression, boolean isJoinCondition, boolean isLValue) {
+ String expLang = getExpressionLanguage(expression);
+ ExpressionCompiler ec = findExpLangCompiler(expLang);
+ ec.setCompilerContext(this);
+
+ try {
+ OExpression oexpr = (isJoinCondition) ? ec.compileJoinCondition(expression) : ec.compile(expression);
+
+ oexpr.debugInfo = createDebugInfo(expression, expression.toString());
+
+ OExpressionLanguage expLanguage = _expLanguages.get(expLang);
+ if (expLanguage == null) {
+ expLanguage = new OExpressionLanguage(_oprocess, ec.getProperties());
+ expLanguage.debugInfo = createDebugInfo(_processDef, "Expression Language: " + expLang);
+ expLanguage.expressionLanguageUri = expLang;
+ _expLanguages.put(expLang, expLanguage);
+ _oprocess.expressionLanguages.add(expLanguage);
+ }
+ oexpr.expressionLanguage = expLanguage;
+
+ // Cleaning up expression compiler for furter compilation
+ ec.setCompilerContext(null);
+
+ return oexpr;
+ } catch (CompilationException ce) {
+ if (ce.getCompilationMessage().source == null)
+ ce.getCompilationMessage().setSource(expression);
+ throw ce;
+ }
+ }
+
+ public OProcess getOProcess() throws CompilationException {
+ return _oprocess;
+ }
+
+ public void recoveredFromError(SourceLocation where, CompilationException bce) throws CompilationException {
+ if (bce.getCompilationMessage().source == null)
+ bce.getCompilationMessage().source = where;
+
+ if (_compileListener == null) {
+ switch (bce.getCompilationMessage().severity) {
+ case CompilationMessage.INFO:
+ if (__log.isInfoEnabled()) {
+ __log.info(bce.toErrorMessage());
+ }
+ break;
+ case CompilationMessage.WARN:
+ if (__log.isWarnEnabled()) {
+ __log.warn(bce.toErrorMessage());
+ }
+ break;
+ case CompilationMessage.ERROR:
+ if (__log.isErrorEnabled()) {
+ __log.error(bce.toErrorMessage());
+ }
+ }
+ } else {
+ if (__log.isDebugEnabled()) {
+ __log.debug(bce.toErrorMessage(), bce);
+ }
+ _compileListener.onCompilationMessage(bce.getCompilationMessage());
+ }
+
+ _errors.add(bce.getCompilationMessage());
+ }
+
+ /**
+ * Compile a process.
+ */
+ public OProcess compile(final Process process, ResourceFinder rf) throws CompilationException {
+ if (process == null)
+ throw new NullPointerException("Null process parameter");
+
+ setResourceFinder(rf);
+ _processURI = process.getURI();
+ _processDef = process;
+ _generatedDate = new Date();
+ _structureStack.clear();
+
+ String bpelVersionUri = null;
+ switch (process.getBpelVersion()) {
+ case BPEL11:
+ bpelVersionUri = Bpel11QNames.NS_BPEL4WS_2003_03;
+ break;
+ case BPEL20_DRAFT:
+ bpelVersionUri = Bpel20QNames.NS_WSBPEL2_0;
+ break;
+ case BPEL20:
+ bpelVersionUri = Bpel20QNames.NS_WSBPEL2_0_FINAL_EXEC;
+ break;
+ default:
+ throw new IllegalStateException("Bad bpel version: " + process.getBpelVersion());
+ }
+
+ _oprocess = new OProcess(bpelVersionUri);
+ _oprocess.guid = new GUID().toString();
+ _oprocess.constants = makeConstants();
+ _oprocess.debugInfo = createDebugInfo(process, "process");
+
+ if (process.getTargetNamespace() == null) {
+ _oprocess.targetNamespace = "--UNSPECIFIED--";
+ recoveredFromError(process, new CompilationException(__cmsgs.errProcessNamespaceNotSpecified()));
+ } else {
+ _oprocess.targetNamespace = _processDef.getTargetNamespace();
+ }
+
+ if (process.getName() == null) {
+ _oprocess.processName = "--UNSPECIFIED--";
+ recoveredFromError(process, new CompilationException(__cmsgs.errProcessNameNotSpecified()));
+ } else {
+ _oprocess.processName = _processDef.getName();
+ }
+
+ _oprocess.compileDate = _generatedDate;
+
+ _konstExprLang = new OExpressionLanguage(_oprocess, null);
+ _konstExprLang.debugInfo = createDebugInfo(_processDef, "Constant Value Expression Language");
+ _konstExprLang.expressionLanguageUri = "uri:www.fivesight.com/konstExpression";
+ _konstExprLang.properties.put("runtime-class",
+ "org.apache.ode.bpel.runtime.explang.konst.KonstExpressionLanguageRuntimeImpl");
+ _oprocess.expressionLanguages.add(_konstExprLang);
+
+ // Process the imports. Note, we expect all processes (Event BPEL 1.1)
+ // to have an import declaration. This should be automatically generated
+ // by the 1.1 parser.
+ for (Import imprt : _processDef.getImports()) {
+ try {
+ compile(_processURI, imprt);
+ } catch (CompilationException bce) {
+ // We try to recover from import problems by continuing
+ recoveredFromError(imprt, bce);
+ }
+ }
+
+ switch (_processDef.getSuppressJoinFailure()) {
+ case NO:
+ case NOTSET:
+ _supressJoinFailure = false;
+ break;
+ case YES:
+ _supressJoinFailure = true;
+ break;
+ }
+ // compile ALL wsdl properties; needed for property extraction
+ Definition4BPEL[] defs = _wsdlRegistry.getDefinitions();
+ for (Definition4BPEL def : defs) {
+ for (Property property : def.getProperties()) {
+ compile(property);
+ }
+ }
+ // compile ALL wsdl property aliases
+ for (Definition4BPEL def1 : defs) {
+ for (PropertyAlias propertyAlias : def1.getPropertyAliases()) {
+ compile(propertyAlias);
+ }
+ }
+
+ // compile extensions
+ for (Extension e : _processDef.getExtensions()) {
+ compileExtension(e);
+ }
+
+ OScope procesScope = new OScope(_oprocess, null);
+ procesScope.name = "__PROCESS_SCOPE:" + process.getName();
+ procesScope.debugInfo = createDebugInfo(process, null);
+ _oprocess.procesScope = compileScope(procesScope, process, new Runnable() {
+ public void run() {
+ if (process.getRootActivity() == null) {
+ throw new CompilationException(__cmsgs.errNoRootActivity());
+ }
+ // Process custom properties are created as variables associated
+ // with the top scope
+ if (_customProcessProperties != null) {
+ for (Map.Entry<QName, Node> customVar : _customProcessProperties.entrySet()) {
+ final OScope oscope = _structureStack.topScope();
+ OVarType varType = new OConstantVarType(_oprocess, customVar.getValue());
+ OScope.Variable ovar = new OScope.Variable(_oprocess, varType);
+ ovar.name = customVar.getKey().getLocalPart();
+ ovar.declaringScope = oscope;
+ ovar.debugInfo = createDebugInfo(null, "Process custom property variable");
+ oscope.addLocalVariable(ovar);
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled custom property variable " + ovar);
+ }
+ }
+ _structureStack.topScope().activity = compile(process.getRootActivity());
+ }
+ });
+
+ assert _structureStack.size() == 0;
+
+ boolean hasErrors = false;
+ StringBuffer sb = new StringBuffer();
+ for (CompilationMessage msg : _errors) {
+ if (msg.severity >= CompilationMessage.ERROR) {
+ hasErrors = true;
+ sb.append('\t');
+ sb.append(msg.toErrorString());
+ sb.append('\n');
+ }
+ }
+
+ if (hasErrors) {
+ throw new CompilationException(__cmsgs.errCompilationErrors(_errors.size(), sb.toString()));
+ }
+ return _oprocess;
+ }
+
+ // TODO unused?
+ // private String getBpelPartnerLinkUri(){
+ // switch(_processDef.getBpelVersion()){
+ // case Process.BPEL_V110:
+ // return Constants.NS_BPEL4WS_PARTNERLINK_2003_05;
+ // case Process.BPEL_V200:
+ // return Constants.NS_WSBPEL_PARTNERLINK_2004_03;
+ // default:
+ // throw new IllegalStateException("Bad bpel version.");
+ // }
+ // }
+
+ /**
+ * Compile an import declaration. According to the specification: <blockquote> A BPEL4WSWS-BPEL process definition relies on XML
+ * Schema and WSDL 1.1 for the definition of datatypes and service interfaces. Process definitions also rely on other constructs
+ * such as partner link types, message properties and property aliases (defined later in this specification) which are defined
+ * within WSDL 1.1 documents using the WSDL 1.1 language extensibility feature.
+ *
+ * The <import> element is used within a BPEL4WSWS-BPEL process to explicitly indicate a dependency on external XML Schema
+ * or WSDL definitions. Any number of <import> elements may appear as initial children of the <process> element, before any
+ * other child element. Each <import> element contains three mandatory attributes:
+ * <ol>
+ * <li>namespace -- The namespace attribute specifies the URI namespace of the imported definitions. </li>
+ * <li>location -- The location attribute contains a URI indicating the location of a document that contains relevant
+ * definitions in the namespace specified. The document located at the URI MUST contain definitions belonging to the same
+ * namespace as indicated by the namespace attribute. </li>
+ * <li>importType -- The importType attribute identifies the type of document being imported by providing the URI of the
+ * encoding language. The value MUST be set to "http://www.w3.org/2001/XMLSchema" when importing XML Schema 1.0 documents, and
+ * to "http://schemas.xmlsoap.org/wsdl/" when importing WSDL 1.1 documents.
+ *
+ * @param imprt
+ * BOM representation of the import
+ */
+ private void compile(URI current, Import imprt) {
+ try {
+ if (imprt.getImportType() == null)
+ throw new CompilationException(__cmsgs.errUnspecifiedImportType().setSource(imprt));
+
+ if (imprt.getLocation() == null)
+ throw new CompilationException(__cmsgs.errMissingImportLocation().setSource(imprt));
+
+ if (Import.IMPORTTYPE_WSDL11.equals(imprt.getImportType())) {
+ addWsdlImport(current, imprt.getLocation(), imprt);
+ } else if (Import.IMPORTTYPE_XMLSCHEMA10.equals(imprt.getImportType())) {
+ addXsdImport(current, imprt.getLocation(), imprt);
+ } else
+ throw new CompilationException(__cmsgs.errUnknownImportType(imprt.getImportType()).setSource(imprt));
+ } catch (CompilationException ce) {
+ if (ce.getCompilationMessage().source == null)
+ ce.getCompilationMessage().setSource(imprt);
+ throw ce;
+ }
+ }
+
+ public OActivity compile(final Activity source) {
+ if (source == null)
+ throw new IllegalArgumentException("null-argument");
+
+ boolean previousSupressJoinFailure = _supressJoinFailure;
+ switch (source.getSuppressJoinFailure()) {
+ case NO:
+ _supressJoinFailure = false;
+ break;
+ case YES:
+ _supressJoinFailure = true;
+ break;
+ }
+
+ OActivity compiled;
+ try {
+ compiled = (source instanceof ScopeLikeActivity) ? compileSLC((ScopeLikeActivity) source, new OScope.Variable[0])
+ : compileActivity(true, source);
+ compiled.suppressJoinFailure = _supressJoinFailure;
+ } finally {
+ _supressJoinFailure = previousSupressJoinFailure;
+ }
+
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled activity " + compiled);
+ return compiled;
+ }
+
+ private OCompensate createDefaultCompensateActivity(BpelObject source, String desc) {
+ OCompensate activity = new OCompensate(_oprocess, getCurrent());
+ activity.name = "__autoGenCompensate:" + _structureStack.topScope().name;
+ activity.debugInfo = createDebugInfo(source, desc);
+ return activity;
+ }
+
+ public OScope compileSLC(final ScopeLikeActivity source, final OScope.Variable[] variables) {
+ final OScope implicitScope = new OScope(_oprocess, getCurrent());
+ implicitScope.implicitScope = true;
+ implicitScope.name = createName(source, "implicit-scope");
+ implicitScope.debugInfo = createDebugInfo(source, "Scope-like construct " + source);
+ compileScope(implicitScope, source.getScope(), new Runnable() {
+ public void run() {
+ compileLinks(source);
+ for (OScope.Variable v : variables) {
+ v.declaringScope = implicitScope;
+ implicitScope.addLocalVariable(v);
+ }
+ if (source instanceof ScopeActivity) {
+ Activity scopeChild = ((ScopeActivity) source).getChildActivity();
+ if (scopeChild == null)
+ throw new CompilationException(__cmsgs.errEmptyScope().setSource(source));
+ implicitScope.activity = compile(scopeChild);
+ } else {
+ implicitScope.activity = compileActivity(false, source);
+ }
+ }
+ });
+
+ return implicitScope;
+ }
+
+ private OActivity compileActivity(final boolean doLinks, final Activity source) {
+ final ActivityGenerator actgen = findActivityGen(source);
+ final OActivity oact = actgen.newInstance(source);
+ oact.name = createName(source, "activity");
+ oact.debugInfo = createDebugInfo(source, "Activity body for " + source);
+ _compiledActivities.add(oact);
+ compile(oact, source, new Runnable() {
+ public void run() {
+ if (doLinks)
+ compileLinks(source);
+ actgen.compile(oact, source);
+ }
+ });
+
+ return oact;
+ }
+
+ private void compileLinks(Activity source) {
+ /* Source Links Fixup */
+ for (LinkSource ls : source.getLinkSources())
+ compileLinkSource(ls);
+
+ /* Target Links Fixup */
+ for (LinkTarget lt : source.getLinkTargets())
+ compileLinkTarget(lt);
+
+ _structureStack.topActivity().joinCondition = (source.getJoinCondition() == null || source.getLinkTargets().isEmpty()) ? null
+ : compileJoinCondition(source.getJoinCondition());
+ }
+
+ private String createName(Activity source, String type) {
+ if (source.getName() != null)
+ return source.getName();
+
+ return source.getType().getLocalPart() + "-" + type + "-line-" + source.getLineNo();
+ }
+
+ private OProcess.OProperty compile(Property property) {
+ OProcess.OProperty oproperty = new OProcess.OProperty(_oprocess);
+ oproperty.name = property.getName();
+ oproperty.debugInfo = createDebugInfo(_processDef, "Property " + property.getName());
+
+ boolean simpleType = false;
+ try {
+ simpleType = _wsdlRegistry.getSchemaModel().isSimpleType(property.getPropertyType());
+ } catch (NullPointerException npe) {
+ // Relying on the following check
+ }
+ if (!simpleType)
+ throw new CompilationException(__cmsgs.errPropertyDeclaredWithComplexType(property.getName(),
+ property.getPropertyType()).setSource(property));
+
+ _oprocess.properties.add(oproperty);
+
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled property " + oproperty);
+
+ return oproperty;
+ }
+
+ private OProcess.OPropertyAlias compile(PropertyAlias src) {
+ OProcess.OProperty property = resolveProperty(src.getPropertyName());
+
+ OProcess.OPropertyAlias alias = new OProcess.OPropertyAlias(_oprocess);
+ alias.debugInfo = createDebugInfo(_processDef, "PropertyAlias " + src.getPropertyName() + " for " + src.getMessageType());
+ if (src.getMessageType() == null) {
+ throw new CompilationException(__cmsgs.errAliasUndeclaredMessage(src.getPropertyName(), src.getQuery().getPath()));
+ }
+
+ OMessageVarType messageType = resolveMessageType(src.getMessageType());
+ alias.varType = messageType;
+ // bpel 2.0 excludes declaration of part;
+ // bpel 1.1 requires it
+ if (src.getPart() != null) {
+ alias.part = messageType.parts.get(src.getPart());
+ if (alias.part == null)
+ throw new CompilationException(__cmsgs.errUnknownPartInAlias(src.getPart(), messageType.messageType.toString()));
+ }
+ if (src.getQuery() != null)
+ alias.location = compileExpr(src.getQuery());
+ property.aliases.add(alias);
+ alias.debugInfo = createDebugInfo(_processDef, src.getMessageType() + " --> " + src.getPropertyName());
+ return alias;
+ }
+
+ private void compileLinkTarget(LinkTarget target) {
+ OLink ol = resolveLink(target.getLinkName());
+ assert ol != null;
+ ol.debugInfo = createDebugInfo(target, target.toString());
+ if (ol.target != null)
+ throw new CompilationException(__cmsgs.errDuplicateLinkTarget(target.getLinkName()).setSource(target));
+ ol.target = _structureStack.topActivity();
+
+ _structureStack.topActivity().targetLinks.add(ol);
+ }
+
+ private void compileLinkSource(LinkSource linksrc) {
+ OLink ol = resolveLink(linksrc.getLinkName());
+ assert ol != null;
+ ol.debugInfo = createDebugInfo(linksrc, linksrc.toString());
+ if (ol.source != null)
+ throw new CompilationException(__cmsgs.errDuplicateLinkSource(linksrc.getLinkName()).setSource(linksrc));
+ ol.source = _structureStack.topActivity();
+ ol.transitionCondition = linksrc.getTransitionCondition() == null ? constantExpr(true) : compileExpr(linksrc
+ .getTransitionCondition());
+
+ _structureStack.topActivity().sourceLinks.add(ol);
+ _structureStack.topActivity().outgoingLinks.add(ol);
+ }
+
+ private void compile(final PartnerLink plink) {
+ OPartnerLink oplink = new OPartnerLink(_oprocess);
+ oplink.debugInfo = createDebugInfo(plink, plink.toString());
+ try {
+ PartnerLinkType plinkType = resolvePartnerLinkType(plink.getPartnerLinkType());
+
+ oplink.partnerLinkType = plinkType.getName();
+ oplink.name = plink.getName();
+ oplink.initializePartnerRole = plink.isInitializePartnerRole();
+
+ if (plink.hasMyRole()) {
+ PartnerLinkType.Role myRole = plinkType.getRole(plink.getMyRole());
+ if (myRole == null)
+ throw new CompilationException(__cmsgs.errUndeclaredRole(plink.getMyRole(), plinkType.getName()));
+ oplink.myRoleName = myRole.getName();
+ QName portType = myRole.getPortType();
+ if (portType == null)
+ throw new CompilationException(__cmsgs.errMissingMyRolePortType(portType, plink.getMyRole(), plinkType
+ .getName()));
+ oplink.myRolePortType = resolvePortType(portType);
+ }
+
+ if (plink.isInitializePartnerRole() && !plink.hasPartnerRole()) {
+ throw new CompilationException(__cmsgs.errPartnerLinkNoPartnerRoleButInitialize(plink.getName()));
+ }
+ if (plink.hasPartnerRole()) {
+ PartnerLinkType.Role partnerRole = plinkType.getRole(plink.getPartnerRole());
+ if (partnerRole == null)
+ throw new CompilationException(__cmsgs.errUndeclaredRole(plink.getPartnerRole(), plinkType.getName()));
+ oplink.partnerRoleName = partnerRole.getName();
+ QName portType = partnerRole.getPortType();
+ if (portType == null)
+ throw new CompilationException(__cmsgs.errMissingPartnerRolePortType(portType, plink.getPartnerRole(),
+ plinkType.getName()));
+ oplink.partnerRolePortType = resolvePortType(portType);
+ }
+
+ oplink.declaringScope = _structureStack.topScope();
+ if (oplink.declaringScope.partnerLinks.containsKey(oplink.name))
+ throw new CompilationException(__cmsgs.errDuplicatePartnerLinkDecl(oplink.name));
+ oplink.declaringScope.partnerLinks.put(oplink.name, oplink);
+ _oprocess.allPartnerLinks.add(oplink);
+ } catch (CompilationException ce) {
+ ce.getCompilationMessage().setSource(plink);
+ throw ce;
+ }
+ }
+
+ private void compile(CorrelationSet cset) {
+ OScope oscope = _structureStack.topScope();
+ OScope.CorrelationSet ocset = new OScope.CorrelationSet(_oprocess);
+ ocset.name = cset.getName();
+ ocset.declaringScope = oscope;
+ ocset.debugInfo = createDebugInfo(cset, cset.toString());
+ QName[] setprops = cset.getProperties();
+ for (int j = 0; j < setprops.length; ++j)
+ ocset.properties.add(resolveProperty(setprops[j]));
+ oscope.addCorrelationSet(ocset);
+ }
+
+ public OActivity getCurrent() {
+ return _structureStack.topActivity();
+ }
+
+ public void compile(OActivity context, BpelObject source, Runnable run) {
+ DefaultActivityGenerator.defaultExtensibilityElements(context, source);
+ _structureStack.push(context, source);
+ try {
+ run.run();
+ } finally {
+ OActivity popped = _structureStack.pop();
+
+ OActivity newtop = _structureStack.topActivity();
+ OScope topScope = _structureStack.topScope();
+
+ if (newtop != null) {
+ newtop.nested.add(popped);
+ // Transfer outgoing and incoming links, excluding the locally defined links.
+ newtop.incomingLinks.addAll(popped.incomingLinks);
+ if (newtop instanceof OFlow) newtop.incomingLinks.removeAll(((OFlow) newtop).localLinks);
+ newtop.outgoingLinks.addAll(popped.outgoingLinks);
+
+ if (newtop instanceof OFlow) newtop.outgoingLinks.removeAll(((OFlow) newtop).localLinks);
+
+ // Transfer variables read/writen
+ newtop.variableRd.addAll(popped.variableRd);
+ newtop.variableWr.addAll(popped.variableWr);
+ }
+
+ if (topScope != null && popped instanceof OScope) topScope.compensatable.add((OScope) popped);
+ }
+ }
+
+ private OScope compileScope(final OScope oscope, final Scope src, final Runnable init) {
+ if (oscope.name == null)
+ throw new IllegalArgumentException("Unnamed scope:" + src);
+
+ oscope.debugInfo = createDebugInfo(src, src.toString());
+
+ boolean previousAtomicScope = _atomicScope;
+ if (src.getAtomicScope() != null) {
+ boolean newValue = src.getAtomicScope().booleanValue();
+ if (_atomicScope)
+ throw new CompilationException(__cmsgs.errAtomicScopeNesting(newValue));
+
+ oscope.atomicScope = _atomicScope = newValue;
+ }
+
+ if (src.getIsolatedScope() != null) {
+ if (src.getIsolatedScope()) {
+ if (_isolatedScope)
+ throw new CompilationException(__cmsgs.errIsolatedScopeNesting());
+
+ oscope.isolatedScope = _isolatedScope = true;
+ }
+ }
+
+ try {
+ compile(oscope, src, new Runnable() {
+ public void run() {
+ for (Variable var : src.getVariables()) {
+ try {
+ compile(var);
+ } catch (CompilationException ce) {
+ recoveredFromError(var, ce);
+ }
+ }
+
+ for (CorrelationSet cset : src.getCorrelationSetDecls()) {
+ try {
+ compile(cset);
+ } catch (CompilationException ce) {
+ recoveredFromError(cset, ce);
+ }
+ }
+
+ for (PartnerLink plink : src.getPartnerLinks()) {
+ try {
+ compile(plink);
+ } catch (CompilationException ce) {
+ recoveredFromError(plink, ce);
+ }
+ }
+
+ if (!src.getEvents().isEmpty() || !src.getAlarms().isEmpty()) {
+ oscope.eventHandler = new OEventHandler(_oprocess);
+ oscope.eventHandler.debugInfo = createDebugInfo(src, "Event Handler for " + src);
+ }
+
+ for (OnEvent onEvent : src.getEvents()) {
+ try {
+ compile(onEvent);
+ } catch (CompilationException ce) {
+ recoveredFromError(src, ce);
+ }
+ }
+
+ for (OnAlarm onAlarm : src.getAlarms()) {
+ try {
+ compile(onAlarm);
+ } catch (CompilationException ce) {
+ recoveredFromError(src, ce);
+ }
+
+ }
+
+ if (init != null)
+ try {
+ init.run();
+ } catch (CompilationException ce) {
+ recoveredFromError(src, ce);
+ }
+
+ try {
+ compile(src.getCompensationHandler());
+ } catch (CompilationException bce) {
+ recoveredFromError(src.getCompensationHandler(), bce);
+ }
+
+ try {
+ compile(src.getTerminationHandler());
+ } catch (CompilationException bce) {
+ recoveredFromError(src.getTerminationHandler(), bce);
+ }
+
+ try {
+ compile(src.getFaultHandler());
+ } catch (CompilationException bce) {
+ recoveredFromError(src.getFaultHandler(), bce);
+ }
+ }
+ });
+ } finally {
+ _atomicScope = previousAtomicScope;
+ }
+
+ return oscope;
+ }
+
+ private void compile(final OnAlarm onAlarm) {
+ OScope oscope = _structureStack.topScope();
+ assert oscope.eventHandler != null;
+
+ final OEventHandler.OAlarm oalarm = new OEventHandler.OAlarm(_oprocess);
+ oalarm.debugInfo = createDebugInfo(onAlarm, "OnAlarm Event Handler: " + onAlarm);
+
+ if (onAlarm.getFor() != null && onAlarm.getUntil() == null) {
+ oalarm.forExpr = compileExpr(onAlarm.getFor());
+ } else if (onAlarm.getFor() == null && onAlarm.getUntil() != null) {
+ oalarm.untilExpr = compileExpr(onAlarm.getUntil());
+ } else if (onAlarm.getFor() != null && onAlarm.getUntil() != null) {
+ throw new CompilationException(__cmsgs.errInvalidAlarm().setSource(onAlarm));
+ } else if (onAlarm.getRepeatEvery() == null) {
+ throw new CompilationException(__cmsgs.errInvalidAlarm().setSource(onAlarm));
+ }
+
+ if (onAlarm.getRepeatEvery() != null)
+ oalarm.repeatExpr = compileExpr(onAlarm.getRepeatEvery());
+
+ if (onAlarm.getActivity() == null) throw new CompilationException(__cmsgs.errInvalidAlarm().setSource(onAlarm));
+ oalarm.activity = compile(onAlarm.getActivity());
+
+ // Check links crossing restrictions.
+ for (OLink link : oalarm.incomingLinks)
+ try {
+ throw new CompilationException(__cmsgs.errLinkCrossesEventHandlerBoundary(link.name).setSource(onAlarm));
+ } catch (CompilationException ce) {
+ recoveredFromError(onAlarm, ce);
+ }
+
+ for (OLink link : oalarm.outgoingLinks)
+ try {
+ throw new CompilationException(__cmsgs.errLinkCrossesEventHandlerBoundary(link.name).setSource(onAlarm));
+ } catch (CompilationException ce) {
+ recoveredFromError(onAlarm, ce);
+ }
+
+ oscope.eventHandler.onAlarms.add(oalarm);
+ }
+
+ private void compile(final OnEvent onEvent) {
+ final OScope oscope = _structureStack.topScope();
+ assert oscope.eventHandler != null;
+
+ final OEventHandler.OEvent oevent = new OEventHandler.OEvent(_oprocess, oscope);
+ oevent.name = "__eventHandler:";
+ oevent.debugInfo = createDebugInfo(onEvent, null);
+ compile(oevent, onEvent, new Runnable() {
+ public void run() {
+ switch (_processDef.getBpelVersion()) {
+ case BPEL11:
+ oevent.variable = resolveMessageVariable(onEvent.getVariable());
+ break;
+ case BPEL20_DRAFT:
+ case BPEL20:
+ if (onEvent.getMessageType() == null && onEvent.getElementType() == null)
+ throw new CompilationException(__cmsgs.errVariableDeclMissingType(onEvent.getVariable()).setSource(onEvent));
+ if (onEvent.getMessageType() != null && onEvent.getElementType() != null)
+ throw new CompilationException(__cmsgs.errVariableDeclInvalid(onEvent.getVariable()).setSource(onEvent));
+
+ OVarType varType;
+ if (onEvent.getMessageType() != null)
+ varType = resolveMessageType(onEvent.getMessageType());
+ else if (onEvent.getElement() != null)
+ varType = resolveElementType(onEvent.getElementType());
+ else
+ throw new CompilationException(__cmsgs.errUnrecognizedVariableDeclaration(onEvent.getVariable()));
+
+ oevent.variable = new OScope.Variable(_oprocess, varType);
+ oevent.variable.name = onEvent.getVariable();
+ oevent.variable.declaringScope = _structureStack.topScope();
+
+ oevent.addLocalVariable(oevent.variable);
+ break;
+ default:
+ throw new AssertionError("Unexpected BPEL VERSION constatnt: " + _processDef.getBpelVersion());
+ }
+
+ oevent.partnerLink = resolvePartnerLink(onEvent.getPartnerLink());
+ oevent.operation = resolveMyRoleOperation(oevent.partnerLink, onEvent.getOperation());
+ oevent.messageExchangeId = onEvent.getMessageExchangeId();
+
+ if (onEvent.getPortType() != null && !onEvent.getPortType().equals(oevent.partnerLink.myRolePortType.getQName()))
+ throw new CompilationException(__cmsgs.errPortTypeMismatch(onEvent.getPortType(),
+ oevent.partnerLink.myRolePortType.getQName()));
+
+ for (Correlation correlation : onEvent.getCorrelations()) {
+ OScope.CorrelationSet cset = resolveCorrelationSet(correlation.getCorrelationSet());
+
+ switch (correlation.getInitiate()) {
+ case UNSET:
+ case NO:
+ if (oevent.matchCorrelation != null)
+ throw new CompilationException(__cmsgs.errTODO("Matching multiple correlations sets."));
+ oevent.matchCorrelation = cset;
+ oevent.partnerLink.addCorrelationSetForOperation(oevent.operation, cset);
+ break;
+ case YES:
+ oevent.initCorrelations.add(cset);
+ break;
+ case JOIN:
+ throw new CompilationException(__cmsgs.errTODO("Rendezvous."));
+ }
+
+ for (OProcess.OProperty property : cset.properties) {
+ // Force resolution of alias, to make sure that we have
+ // one for this variable-property pair.
+ resolvePropertyAlias(oevent.variable, property.name);
+ }
+
+ }
+
+ if (onEvent.getActivity() == null) throw new CompilationException(__cmsgs.errInvalidAlarm().setSource(onEvent));
+ oevent.activity = compile(onEvent.getActivity());
+ }
+ });
+
+ // Check links crossing restrictions.
+ for (OLink link : oevent.incomingLinks)
+ try {
+ throw new CompilationException(__cmsgs.errLinkCrossesEventHandlerBoundary(link.name));
+ } catch (CompilationException ce) {
+ recoveredFromError(onEvent, ce);
+ }
+
+ for (OLink link : oevent.outgoingLinks)
+ try {
+ throw new CompilationException(__cmsgs.errLinkCrossesEventHandlerBoundary(link.name));
+ } catch (CompilationException ce) {
+ recoveredFromError(onEvent, ce);
+ }
+
+ oscope.eventHandler.onMessages.add(oevent);
+ }
+
+ private DebugInfo createDebugInfo(BpelObject bpelObject, String description) {
+ int lineNo = bpelObject == null ? -1 : bpelObject.getLineNo();
+ String str = description == null && bpelObject != null ? bpelObject.toString() : null;
+ Map<QName, Object> extElmt = bpelObject == null ? null : bpelObject.getExtensibilityElements();
+ DebugInfo debugInfo = new DebugInfo(_processDef.getSource(), lineNo, extElmt);
+ debugInfo.description = str;
+ return debugInfo;
+ }
+
+ private void compile(final Variable src) {
+ final OScope oscope = _structureStack.topScope();
+
+ if (src.getKind() == null)
+ throw new CompilationException(__cmsgs.errVariableDeclMissingType(src.getName()).setSource(src));
+
+ if (oscope.getLocalVariable(src.getName()) != null)
+ throw new CompilationException(__cmsgs.errDuplicateVariableDecl(src.getName()).setSource(src));
+
+ if (src.getTypeName() == null) throw new CompilationException(__cmsgs.errUnrecognizedVariableDeclaration(src.getName()));
+ OVarType varType;
+ switch (src.getKind()) {
+ case ELEMENT:
+ varType = resolveElementType(src.getTypeName());
+ break;
+ case MESSAGE:
+ varType = resolveMessageType(src.getTypeName());
+ break;
+ case SCHEMA:
+ varType = resolveXsdType(src.getTypeName());
+ break;
+ default:
+ throw new CompilationException(__cmsgs.errUnrecognizedVariableDeclaration(src.getName()));
+ }
+
+ OScope.Variable ovar = new OScope.Variable(_oprocess, varType);
+ ovar.name = src.getName();
+ ovar.declaringScope = oscope;
+ ovar.debugInfo = createDebugInfo(src, null);
+
+ ovar.extVar = compileExtVar(src);
+
+ oscope.addLocalVariable(ovar);
+
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled variable " + ovar);
+ }
+
+
+ private void compile(TerminationHandler terminationHandler) {
+ OScope oscope = _structureStack.topScope();
+ oscope.terminationHandler = new OTerminationHandler(_oprocess, oscope);
+ oscope.terminationHandler.name = "__terminationHandler:" + oscope.name;
+ oscope.terminationHandler.debugInfo = createDebugInfo(terminationHandler, null);
+ if (terminationHandler == null) {
+ oscope.terminationHandler.activity = createDefaultCompensateActivity(null,
+ "Auto-generated 'compensate all' pseudo-activity for default termination handler on " + oscope.toString());
+ } else {
+ _recoveryContextStack.push(oscope);
+ try {
+ oscope.terminationHandler.activity = compile(terminationHandler.getActivity());
+ } finally {
+ _recoveryContextStack.pop();
+ }
+ }
+ }
+
+ private void compile(CompensationHandler compensationHandler) {
+ OScope oscope = _structureStack.topScope();
+ oscope.compensationHandler = new OCompensationHandler(_oprocess, oscope);
+ oscope.compensationHandler.name = "__compenationHandler_" + oscope.name;
+ oscope.compensationHandler.debugInfo = createDebugInfo(compensationHandler, null);
+ if (compensationHandler == null) {
+ oscope.compensationHandler.activity = createDefaultCompensateActivity(compensationHandler,
+ "Auto-generated 'compensate all' pseudo-activity for default compensation handler on " + oscope.toString());
+ } else {
+ _recoveryContextStack.push(oscope);
+ try {
+ oscope.compensationHandler.activity = compile(compensationHandler.getActivity());
+ } finally {
+ _recoveryContextStack.pop();
+ }
+ }
+ }
+
+ private void compile(FaultHandler fh) {
+ OScope oscope = _structureStack.topScope();
+ oscope.faultHandler = new OFaultHandler(_oprocess);
+ if (fh == null) {
+ // The default fault handler compensates all child activities
+ // AND then rethrows the fault!
+ final OCatch defaultCatch = new OCatch(_oprocess, oscope);
+ defaultCatch.name = "__defaultFaultHandler:" + oscope.name;
+ defaultCatch.faultName = null; // catch any fault
+ defaultCatch.faultVariable = null;
+ OSequence sequence = new OSequence(_oprocess, defaultCatch);
+ sequence.name = "__defaultFaultHandler_sequence:" + oscope.name;
+ sequence.debugInfo = createDebugInfo(fh, "Auto-generated sequence activity.");
+ ORethrow rethrow = new ORethrow(_oprocess, sequence);
+ rethrow.name = "__defaultFaultHandler_rethrow:" + oscope.name;
+ rethrow.debugInfo = createDebugInfo(fh, "Auto-generated re-throw activity.");
+ sequence.sequence.add(createDefaultCompensateActivity(fh, "Default compensation handler for " + oscope));
+ sequence.sequence.add(rethrow);
+
+ defaultCatch.activity = sequence;
+ oscope.faultHandler.catchBlocks.add(defaultCatch);
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled default catch block " + defaultCatch + " for " + oscope);
+
+ } else {
+ _recoveryContextStack.push(oscope);
+ try {
+
+ int i = 0;
+ for (final Catch catchSrc : fh.getCatches()) {
+ final OCatch ctch = new OCatch(_oprocess, oscope);
+ ctch.debugInfo = createDebugInfo(catchSrc, catchSrc.toString());
+ ctch.name = "__catch#" + i + ":" + _structureStack.topScope().name;
+ ctch.faultName = catchSrc.getFaultName();
+ compile(ctch, catchSrc, new Runnable() {
+ public void run() {
+
+ if (catchSrc.getFaultVariable() != null) {
+ OScope.Variable faultVar;
+ switch (_processDef.getBpelVersion()) {
+ case BPEL11:
+ faultVar = resolveVariable(catchSrc.getFaultVariable());
+ if (!(faultVar.type instanceof OMessageVarType))
+ throw new CompilationException(__cmsgs.errMessageVariableRequired(
+ catchSrc.getFaultVariable()).setSource(catchSrc));
+ break;
+ case BPEL20_DRAFT:
+ case BPEL20:
+ if (catchSrc.getFaultVariableMessageType() == null
+ && catchSrc.getFaultVariableElementType() == null)
+ throw new CompilationException(__cmsgs.errVariableDeclMissingType(
+ catchSrc.getFaultVariable()).setSource(catchSrc));
+ if (catchSrc.getFaultVariableMessageType() != null
+ && catchSrc.getFaultVariableElementType() != null)
+ throw new CompilationException(__cmsgs.errVariableDeclMissingType(
+ catchSrc.getFaultVariable()).setSource(catchSrc));
+
+ OVarType faultVarType;
+ if (catchSrc.getFaultVariableMessageType() != null)
+ faultVarType = resolveMessageType(catchSrc.getFaultVariableMessageType());
+ else if (catchSrc.getFaultVariableElementType() != null)
+ faultVarType = resolveElementType(catchSrc.getFaultVariableElementType());
+ else
+ throw new CompilationException(__cmsgs.errUnrecognizedVariableDeclaration(catchSrc
+ .getFaultVariable()));
+
+ faultVar = new OScope.Variable(_oprocess, faultVarType);
+ faultVar.name = catchSrc.getFaultVariable();
+ faultVar.declaringScope = _structureStack.topScope();
+
+ ctch.addLocalVariable(faultVar);
+ break;
+ default:
+ throw new AssertionError("Unexpected BPEL VERSION constatnt: " + _processDef.getBpelVersion());
+ }
+
+ ctch.faultVariable = faultVar;
+ }
+
+ if (catchSrc.getActivity() == null)
+ throw new CompilationException(__cmsgs.errEmptyCatch().setSource(catchSrc));
+ _structureStack.topScope().activity = compile(catchSrc.getActivity());
+ }
+ });
+ oscope.faultHandler.catchBlocks.add(ctch);
+ ++i;
+ }
+ } finally {
+ _recoveryContextStack.pop();
+ }
+
+ }
+ }
+
+ public OXslSheet compileXslt(String docStrUri) throws CompilationException {
+ URI docUri;
+ try {
+ docUri = new URI(FileUtils.encodePath(docStrUri));
+ } catch (URISyntaxException e) {
+ throw new CompilationException(__cmsgs.errInvalidDocXsltUri(docStrUri));
+ }
+
+ String sheetBody = loadXsltSheet(_processURI.resolve(docUri));
+ if (sheetBody == null) {
+ throw new CompilationException(__cmsgs.errCantFindXslt(docStrUri));
+ }
+
+ OXslSheet oXslSheet = new OXslSheet(_oprocess);
+ oXslSheet.uri = docUri;
+ oXslSheet.sheetBody = sheetBody;
+
+ _oprocess.xslSheets.put(oXslSheet.uri, oXslSheet);
+ return oXslSheet;
+ }
+
+ /**
+ * Registers a declared extension.
+ * Since compilation may take place independently of the target
+ * engine configuration, the compiler will not check whether a
+ * extension implementation is registered.
+ */
+ private void compileExtension(Extension ext){
+ OProcess.OExtension oextension = new OProcess.OExtension(_oprocess);
+ oextension.namespaceURI = ext.getNamespaceURI();
+ oextension.mustUnderstand = ext.isMustUnderstand();
+
+ oextension.debugInfo = createDebugInfo(_processDef, "Extension " + ext.getNamespaceURI());
+
+ _declaredExtensionNS.add(ext.getNamespaceURI());
+ _oprocess.declaredExtensions.add(oextension);
+ if (ext.isMustUnderstand()) {
+ _oprocess.mustUnderstandExtensions.add(oextension);
+ }
+
+ if (__log.isDebugEnabled())
+ __log.debug("Compiled extension " + oextension);
+ }
+
+ private String loadXsltSheet(URI uri) {
+
+ // TODO: lots of null returns, should have some better error messages.
+ InputStream is;
+ try {
+ is = _resourceFinder.openResource(uri);
+ } catch (Exception e1) {
+ return null;
+ }
+ if (is == null)
+ return null;
+
+ try {
+ return new String(StreamUtils.read(is));
+ } catch (IOException e) {
+ __log.debug("IO error", e);
+ // todo: this should produce a message
+ return null;
+ } finally {
+ try {
+ is.close();
+ } catch (Exception ex) {
+ // No worries.
+ }
+ }
+ }
+
+ public boolean isPartnerLinkAssigned(String plink) {
+ for (OActivity act : _compiledActivities) {
+ if (act instanceof OAssign) {
+ OAssign assign = (OAssign) act;
+ for (OAssign.OAssignOperation operation: assign.operations) {
+ if (operation instanceof OAssign.Copy) {
+ OAssign.Copy copy = (OAssign.Copy)operation;
+ if (copy.to instanceof OAssign.PartnerLinkRef) {
+ if (((OAssign.PartnerLinkRef) copy.to).partnerLink.getName().equals(plink))
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ public Definition[] getWsdlDefinitions() {
+ Definition[] result = new Definition[_wsdlRegistry.getDefinitions().length];
+ for (int m = 0; m < _wsdlRegistry.getDefinitions().length; m++) {
+ Definition4BPEL definition4BPEL = _wsdlRegistry.getDefinitions()[m];
+ result[m] = definition4BPEL.getDefinition();
+ }
+ return result;
+ }
+
+ private OElementVarType resolveElementType(QName faultVariableElementType) {
+ OElementVarType type = _oprocess.elementTypes.get(faultVariableElementType);
+ if (type == null) {
+ type = new OElementVarType(_oprocess, faultVariableElementType);
+ _oprocess.elementTypes.put(faultVariableElementType, type);
+ }
+ return type;
+ }
+
+ private ActivityGenerator findActivityGen(Activity source) {
+
+ Class actClass = source.getClass();
+
+ for (Map.Entry<Class, ActivityGenerator> me : _actGenerators.entrySet()) {
+ Class<?> cls = me.getKey();
+ if (cls.isAssignableFrom(actClass)) {
+ ActivityGenerator gen = me.getValue();
+ gen.setContext(this);
+ return gen;
+ }
+ }
+
+ throw new CompilationException(__cmsgs.errUnknownActivity(actClass.getName()).setSource(source));
+ }
+
+ protected void registerActivityCompiler(Class defClass, ActivityGenerator generator) {
+ if (__log.isDebugEnabled()) {
+ __log.debug("Adding compiler for nodes class \"" + defClass.getName() + " = " + generator);
+ }
+
+ _actGenerators.put(defClass, generator);
+ }
+
+ private ExpressionCompiler findExpLangCompiler(String expLang) {
+ ExpressionCompiler compiler = _expLanguageCompilers.get(expLang);
+ if (compiler == null) {
+ throw new CompilationException(__cmsgs.errUnknownExpressionLanguage(expLang));
+ }
+ return compiler;
+ }
+
+ private String getExpressionLanguage(Expression exp) {
+ String expLang = exp.getExpressionLanguage();
+
+ if (expLang == null)
+ expLang = _processDef.getExpressionLanguage();
+ if (expLang == null)
+ expLang = getDefaultExpressionLanguage();
+ return expLang;
+ }
+
+ protected abstract String getDefaultExpressionLanguage();
+
+ protected void registerExpressionLanguage(String expLangUri, ExpressionCompiler expressionCompiler) {
+ _expLanguageCompilers.put(expLangUri, expressionCompiler);
+ }
+
+ protected void registerExpressionLanguage(String expLangUri, String classname) {
+ try {
+ Class cls = Class.forName(classname);
+ registerExpressionLanguage(expLangUri, (ExpressionCompiler) cls.newInstance());
+ } catch (ClassNotFoundException e) {
+ throw new RuntimeException(e);
+ } catch (InstantiationException e) {
+ throw new RuntimeException(e);
+ } catch (IllegalAccessException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public void setExtensionValidators(Map<QName, ExtensionValidator> extensionValidators) {
+ _extensionValidators = extensionValidators;
+ }
+
+ public boolean isExtensionDeclared(String namespace) {
+ return _declaredExtensionNS.contains(namespace);
+ }
+
+ public ExtensionValidator getExtensionValidator(QName extensionElementName) {
+ return _extensionValidators.get(extensionElementName);
+ }
+
+ public List<OActivity> getActivityStack() {
+ ArrayList<OActivity> rval = new ArrayList<OActivity>(_structureStack._stack);
+ Collections.reverse(rval);
+ return rval;
+ }
+
+ /**
+ * Compile external variable declaration.
+ * @param src variable object
+ * @return compiled {@link OExtVar} representation.
+ */
+ private OExtVar compileExtVar(Variable src) {
+ if (!src.isExternal())
+ return null;
+
+ OExtVar oextvar = new OExtVar(_oprocess);
+ oextvar.externalVariableId = src.getExternalId();
+ oextvar.debugInfo = createDebugInfo(src, null);
+
+ if (src.getExternalId() == null)
+ throw new CompilationException(__cmsgs.errMustSpecifyExternalVariableId(src.getName()));
+
+ if (src.getRelated() == null)
+ throw new CompilationException(__cmsgs.errMustSpecifyRelatedVariable(src.getName()));
+ oextvar.related = resolveVariable(src.getRelated());
+
+ return oextvar;
+ }
+
+ private static class StructureStack {
+ private Stack<OActivity> _stack = new Stack<OActivity>();
+
+ private Map<OActivity, BpelObject> _srcMap = new HashMap<OActivity, BpelObject>();
+
+ public void push(OActivity act, BpelObject src) {
+ _stack.push(act);
+ _srcMap.put(act, src);
+ }
+
+ public BpelObject topSource() {
+ return _srcMap.get(topActivity());
+ }
+
+ public OScope topScope() {
+ List<OScope> scopeStack = scopeStack();
+ return scopeStack.isEmpty() ? null : scopeStack.get(scopeStack.size() - 1);
+ }
+
+ public OScope rootScope() {
+ for (OActivity oActivity : _stack)
+ if (oActivity instanceof OScope)
+ return (OScope) oActivity;
+ return null;
+ }
+
+ public OActivity pop() {
+ return _stack.pop();
+ }
+
+ public void clear() {
+ _stack.clear();
+ }
+
+ public int size() {
+ return _stack.size();
+ }
+
+ public Iterator<OScope> oscopeIterator() {
+ List<OScope> scopeStack = scopeStack();
+ Collections.reverse(scopeStack);
+ return scopeStack.iterator();
+ }
+
+ private List<OScope> scopeStack() {
+ ArrayList<OScope> newList = new ArrayList<OScope>();
+ CollectionsX.filter(newList, _stack.iterator(), OScope.class);
+ return newList;
+ }
+
+ public OActivity topActivity() {
+ return _stack.isEmpty() ? null : _stack.peek();
+ }
+
+ public Iterator<OActivity> iterator() {
+ ArrayList<OActivity> rval = new ArrayList<OActivity>(_stack);
+ Collections.reverse(rval);
+ return rval.iterator();
+ }
+ }
+}
Added: ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGenerator.java
URL: http://svn.apache.org/viewvc/ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGenerator.java?rev=682542&view=auto
==============================================================================
--- ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGenerator.java (added)
+++ ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGenerator.java Mon Aug 4 16:54:02 2008
@@ -0,0 +1,37 @@
+/*
+ * 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.ode.bpel.compiler.v2;
+
+import org.apache.ode.bpel.compiler.bom.Activity;
+import org.apache.ode.bpel.rtrep.v2.OActivity;
+import org.apache.ode.bpel.rtrep.v2.OCompensate;
+
+
+/**
+ * Generates code for the <code><compensate></code> activities.
+ */
+class CompensateGenerator extends DefaultActivityGenerator {
+
+ public void compile(OActivity output, Activity src) {
+ }
+
+ public OActivity newInstance(Activity src) {
+ return new OCompensate(_context.getOProcess(), _context.getCurrent());
+ }
+}
Added: ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGeneratorMessages.java
URL: http://svn.apache.org/viewvc/ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGeneratorMessages.java?rev=682542&view=auto
==============================================================================
--- ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGeneratorMessages.java (added)
+++ ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateGeneratorMessages.java Mon Aug 4 16:54:02 2008
@@ -0,0 +1,35 @@
+/*
+ * 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.ode.bpel.compiler.v2;
+
+import org.apache.ode.bpel.compiler.api.CompilationMessage;
+import org.apache.ode.bpel.compiler.api.CompilationMessageBundle;
+
+/**
+ * @author Alex Boisvert <boisvert at apache dot org>
+ */
+public class CompensateGeneratorMessages extends CompilationMessageBundle {
+
+ /** The scope to compensate is unspecified. */
+ public CompilationMessage errScopeToCompensateUnspecfied() {
+ return this.formatCompilationMessage("The scope to compensate is unspecified.");
+ }
+
+}
Added: ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateScopeGenerator.java
URL: http://svn.apache.org/viewvc/ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateScopeGenerator.java?rev=682542&view=auto
==============================================================================
--- ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateScopeGenerator.java (added)
+++ ode/branches/rtver/bpel-compiler/src/main/java/org/apache/ode/bpel/compiler/v2/CompensateScopeGenerator.java Mon Aug 4 16:54:02 2008
@@ -0,0 +1,47 @@
+/*
+ * 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.ode.bpel.compiler.v2;
+
+import org.apache.ode.bpel.compiler.api.CompilationException;
+import org.apache.ode.bpel.compiler.bom.Activity;
+import org.apache.ode.bpel.compiler.bom.CompensateScopeActivity;
+import org.apache.ode.bpel.rtrep.v2.OActivity;
+import org.apache.ode.bpel.rtrep.v2.OCompensate;
+import org.apache.ode.utils.msg.MessageBundle;
+
+
+/**
+ * Generates code for the <code><compensateScope></code> activities.
+ */
+class CompensateScopeGenerator extends DefaultActivityGenerator {
+ private static final CompensateGeneratorMessages __cmsgs = MessageBundle.getMessages(CompensateGeneratorMessages.class);
+
+ public void compile(OActivity output, Activity src) {
+ CompensateScopeActivity compSrc = (CompensateScopeActivity) src;
+ if (compSrc.getScopeToCompensate() == null)
+ throw new CompilationException(__cmsgs.errScopeToCompensateUnspecfied());
+ ((OCompensate)output).compensatedScope = _context.resolveCompensatableScope(compSrc.getScopeToCompensate());
+ }
+
+ public OActivity newInstance(Activity src) {
+ return new OCompensate(_context.getOProcess(), _context.getCurrent());
+ }
+}
+