Web Services Business Process Execution Language Version 2.0
Committee Draft, 1st August, 2006
Document identifier:
wsbpel-specification-draft-01
Location:
http://www.oasis-open.org/apps/org/workgroup/wsbpel/
Editors:
Alexandre Alves, BEA
Assaf Arkin, Intalio
Sid Askary
Ben Bloch
Francisco Curbera,
IBM
Yaron Goland, BEA
Neelakantan Kartha, Sterling Commerce
Canyang Kevin Liu,
SAP
Dieter König, IBM
Mike Marin, FileNet
Vinkesh Mehta, Deloitte
Satish Thatte, Microsoft
Danny
van der Rijn, TIBCO Software
Prasad Yendluri,
webMethods
Alex Yiu, Oracle
This document defines a language for specifying business process behavior based on Web Services. This language is called Web Services Business Process Execution Language (abbreviated to WS-BPEL in the rest of this document). Processes in WS-BPEL export and import functionality by using Web Service interfaces exclusively.
Business processes can be described in two ways. Executable business processes model actual behavior of a participant in a business interaction. Abstract business processes are partially specified processes that are not intended to be executed. An Abstract Process may hide some of the required concrete operational details. Abstract Processes serve a descriptive role, with more than one possible use case, including observable behavior and process templating. WS-BPEL is meant to be used to model the behavior of both Executable and Abstract Processes.
WS-BPEL provides a language for the specification of Executable and Abstract business processes. By doing so, it extends the Web Services interaction model and enables it to support business transactions. WS-BPEL defines an interoperable integration model that should facilitate the expansion of automated process integration in both the intra-corporate and the business-to-business spaces.
This is a draft version of the WS-BPEL TC specification, updated from the original BPEL4WS 1.1 specification dated May 5, 2003 that was submitted to the WS-BPEL TC.
If you are on the <wsbpel@lists.oasis-open.org> list for committee members, send comments there. If you are not on that list, subscribe to the <wsbpel-comment@lists.oasis-open.org> list and send comments there. To subscribe, send an email message to <mailto:wsbpel-comment-request@lists.oasis-open.org> with the word "subscribe"as the body of the message.
For information on whether any patents have been disclosed that may be essential to implementing this specification, and any offers of patent licensing terms, please refer to the Intellectual Property Rights section of the WS-BPEL TC web page http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wsbpel
Copyright © 2006 OASIS Open, Inc. All Rights Reserved.
Table of Contents
Web Services Business Process Execution Language Version 2.0
Committee Draft, 1st August, 2006
3. Relationship with Other Specifications
4. Static Analysis of a Business Process
5. Defining a Business Process
5.2. The Structure of a Business Process
5.5. The Lifecycle of an Executable Business Process
5.6. Revisiting the Initial Example
6. Partner Link Types, Partner Links, and Endpoint References
8.2 Usage of Query and Expression Languages
9.2. Declaring and Using Correlation Sets
10.1. Standard Attributes for All Activities
10.2. Standard Elements for All Activities
10.3. Invoking Web Service Operations – Invoke
10.4. Providing Web Service Operations – Receive and Reply
10.5. Updating Variables and Partner Links – Assign
10.6. Signaling Internal Faults – Throw
10.7. Delayed Execution – Wait
10.9. Adding new Activity Types – ExtensionActivity
10.10. Immediately Ending a Process – Exit
10.11. Propagating Faults – Rethrow
11.1. Sequential Processing – Sequence
11.2. Conditional Behavior – If
11.3. Repetitive Execution – While
11.4. Repetitive Execution – RepeatUntil
11.5. Selective Event Processing – Pick
11.6. Parallel and Control Dependencies Processing – Flow
11.7. Processing Multiple Branches – ForEach
12.2. Message Exchange Handling
12.3. Error Handling in Business Processes
13. WS-BPEL Abstract Processes
13.2. Abstract Process Profiles and the Semantics of Abstract Processes
13.3. Abstract Process Profile for Observable Behavior
13.4. Abstract Process Profile for Templates
B. Static Analysis requirement summary (Non-Normative)
D. Examples of Replacement Logic
G. Intellectual Property Rights
J. Committee Members (Non-Normative)
1. Introduction
The goal of the Web Services effort is to achieve interoperability between applications by using Web standards. Web Services use a loosely coupled integration model to allow flexible integration of heterogeneous systems in a variety of domains including business-to-consumer, business-to-business and enterprise application integration. The following basic specifications originally defined the Web Services space: SOAP [SOAP 1.1], Web Services Description Language (WSDL) [WSDL 1.1], and Universal Description, Discovery, and Integration (UDDI) [UDDI]. SOAP defines an XML messaging protocol for basic service interoperability. WSDL introduces a common grammar for describing services. UDDI provides the infrastructure required to publish and discover services in a systematic way. Together, these specifications allow applications to find each other and interact following a loosely coupled, platform independent model.
Systems integration requires more than the ability to conduct simple interactions by using standard protocols. The full potential of Web Services as an integration platform will be achieved only when applications and business processes are able to integrate their complex interactions by using a standard process integration model. The interaction model that is directly supported by WSDL is essentially a stateless model of request-response or uncorrelated one-way interactions.
Models for business interactions typically assume sequences of peer-to-peer message exchanges, both request-response and one-way, within stateful, long-running interactions involving two or more parties. To define such business interactions, a formal description of the message exchange protocols used by business processes in their interactions is needed. An Abstract Process may be used to describe observable message exchange behavior of each of the parties involved, without revealing their internal implementation. There are two good reasons to separate the public aspects of business process behavior from internal or private aspects. One is that businesses obviously do not want to reveal all their internal decision making and data management to their business partners. The other is that, even where this is not the case, separating public from private process provides the freedom to change private aspects of the process implementation without affecting the observable behavior. Observable behavior must clearly be described in a platform independent manner and captures behavioral aspects that may have cross enterprise business significance.
The following concepts for describing business processes should be considered:
· Business processes include data-dependent behavior. For example, a supply-chain process depends on data such as the number of line items in an order, the total value of an order, or a deliver-by deadline. Defining business intent in these cases requires the use of conditional and time-out constructs.
· The ability to specify exceptional conditions and their consequences, including recovery sequences, is at least as important for business processes as the ability to define the behavior in the "all goes well" case.
· Long-running interactions include multiple, often nested units of work, each with its own data requirements. Business processes frequently require cross partner coordination of the outcome (success or failure) of units of work at various levels of granularity.
The basic concepts of WS-BPEL can be applied in one of two ways, Abstract or Executable.
A WS-BPEL Abstract Process is a partially specified process that is not intended to be executed and that must be explicitly declared as ‘abstract’. Whereas Executable Processes are fully specified and thus can be executed, an Abstract Process may hide some of the required concrete operational details expressed by an Executable artifact.
All the constructs of Executables Processes are made available to Abstract Processes; consequently, Executable and Abstract WS-BPEL Processes share the same expressive power. In addition to the features available in Executable Processes, Abstract Processes provide two mechanisms for hiding operational details: (1) the use of explicit opaque tokens and (2) omission. Although a particular Abstract Process definition might contain complete information that would render it Executable, its Abstract status states that any concrete realizations of it are permitted to perform additional processing steps that are not relevant to the audience to which it has been given.
Abstract Processes serve a descriptive role, with more than one use case. One such use case might be to describe the observable behavior of some or all of the services offered by an Executable Process. Another use case would be to define a process template that embodies domain-specific best practices. Such a process template would capture essential process logic in a manner compatible with a design-time representation, while excluding execution details to be completed when mapping to an Executable Process.
Regardless of the specific use case and purpose, all Abstract Processes share a common syntactic base. They have different requirements for the level of opacity and restrictions on which parts of a process definition may be omitted or hidden. Tailored uses of Abstract Processes have different effects on the consistency constraints and on the semantics of that process. Some of these required constraints are not enforceable by the XML Schema.
A common base specifies the features that define the syntactic universe of Abstract Processes. Given this common base, a usage profile provides the necessary specializations and semantics based on Executable WS-BPEL for a particular use of an Abstract Process.
As mentioned above it is possible to use WS-BPEL to define an Executable Business Process. While a WS-BPEL Abstract Process definition is not required to be fully specified, the language effectively defines a portable execution format for business processes that rely exclusively on Web Service resources and XML data. Moreover, such processes execute and interact with their partners in a consistent way regardless of the supporting platform or programming model used by the implementation of the hosting environment.
The continuity of the basic conceptual model between Abstract and Executable Processes in WS-BPEL makes it possible to export and import the public aspects embodied in Abstract Processes as process or role templates while maintaining the intent and structure of the observable behavior. This applies even where private implementation aspects use platform dependent functionality. This is a key feature for the use of WS-BPEL from the viewpoint of unlocking the potential of Web Services because it allows the development of tools and other technologies that greatly increase the level of automation and thereby lower the cost in establishing cross enterprise automated business processes.
In this specification, the description of Abstract Business Processes is presented after Executable. We clearly differentiate concepts required for Abstract Business Process description from the concepts for Executable in the section 13. WS-BPEL Abstract Processes.
WS-BPEL defines a model and a grammar for describing the behavior of a business process based on interactions between the process and its partners. The interaction with each partner occurs through Web Service interfaces, and the structure of the relationship at the interface level is encapsulated in what is called a partnerLink. The WS-BPEL process defines how multiple service interactions with these partners are coordinated to achieve a business goal, as well as the state and the logic necessary for this coordination. WS-BPEL also introduces systematic mechanisms for dealing with business exceptions and processing faults. Moreover, WS-BPEL introduces a mechanism to define how individual or composite activities within a unit of work are to be compensated in cases where exceptions occur or a partner requests reversal.
WS-BPEL utilizes several XML specifications: WSDL 1.1, XML Schema 1.0, XPath 1.0 and XSLT 1.0. WSDL messages and XML Schema type definitions provide the data model used by WS-BPEL processes. XPath and XSLT provide support for data manipulation. All external resources and partners are represented as WSDL services. WS-BPEL provides extensibility to accommodate future versions of these standards, specifically the XPath and related standards used in XML computation.
A WS-BPEL process is a reusable definition that can be deployed in different ways and in different scenarios, while maintaining a uniform application-level behavior across all of them. The description of the deployment of a WS-BPEL process is out of scope for this specification.
2. Notational Conventions
The upper case keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC 2119].
Namespace URIs of the general form "some-URI" represent some application dependent or context dependent URI as defined in [RFC 2396].
This specification uses an informal syntax to describe the XML grammar of the XML fragments that follow:
· The syntax appears as an XML instance, but the values indicate the data types instead of values.
· Grammar in bold has not been introduced earlier in the document, or is of particular interest in an example.
· <-- description --> is a placeholder for elements from some "other" namespace (like ##other in XSD).
· Characters are appended to elements, attributes, and as follows: "?" (0 or 1), "*" (0 or more), "+" (1 or more). The characters "[" and "]" are used to indicate that contained items are to be treated as a group with respect to the "?", "*", or "+" characters.
· Elements and attributes separated by "|" and grouped by "(" and ")" are meant to be syntactic alternatives.
· The XML namespace prefixes (defined below) are used to indicate the namespace of the element being defined.
· The name of user defined extension activity is indicated by anyElementQName.
Syntax specifications are highlighted as follows:
<variables>
<variable name="BPELVariableName"
messageType="QName"?
type="QName"?
element="QName"?>+
from-spec?
</variable>
</variables>
Examples starting with <?xml contain enough information to conform to this specification; other examples are fragments and require additional information to be specified in order to conform.
The examples and other explanatory material in this document are not fully specified unless otherwise noted. For instance, some examples import WSDL definitions that are not specified in this document.
Examples are highlighted as follows:
<variable xmlns:ORD="http://example.com/orders"
name="orderDetails" messageType="ORD:orderDetails" />
XSD Schemas are provided as a formal definition of grammars [XML Schema Part 1].
This specification uses a number of namespace prefixes throughout; their associated URIs are listed below. Note that the choice of any namespace prefix is arbitrary, non-normative and not semantically significant.
· xsi - "http://www.w3.org/2001/XMLSchema-instance"
· xsd - "http://www.w3.org/2001/XMLSchema"
· wsdl - "http://schemas.xmlsoap.org/wsdl/"
· plnk – "urn:oasis:names:tc:wsbpel:2.0:partnerlink"
· bpel – "urn:oasis:names:tc:wsbpel:2.0:process:executable"
· abstract – "urn:oasis:names:tc:wsbpel:2.0:process:abstract"
3. Relationship with Other Specifications
WS-BPEL refers to the following XML-based specifications: WSDL 1.1, XML Schema 1.0, XPath 1.0, XSLT 1.0 and Infoset. All WS-BPEL implementations SHOULD be configurable such that they can participate in Basic Profile 1.1 [WS-I Basic Profile] conforming interactions. A WS-BPEL implementation MAY allow the Basic Profile 1.1 configuration to be disabled, even for scenarios encompassed by the Basic Profile 1.1.
WSDL has the most influence on the WS-BPEL language. The WS-BPEL process model is layered on top of the service model defined by WSDL 1.1. At the core of the WS-BPEL process model is the notion of peer-to-peer interaction between services described in WSDL; both the process and its partners are exposed as WSDL services. A business process defines how to coordinate the interactions between a process instance and its partners. In this sense, a WS-BPEL process definition provides and/or uses one or more WSDL services, and provides the description of the behavior and interactions of a process instance relative to its partners and resources through Web Service interfaces. That is, WS-BPEL is used to describe the message exchanges followed by the business process of a specific role in the interaction.
The definition of a WS-BPEL business process follows the WSDL model of separation between the abstract message contents used by the business process and deployment information (messages and port type versus binding and address information). In particular, a WS-BPEL process represents all partners and interactions with these partners in terms of abstract WSDL interfaces (port types and operations); no references are made to the actual services used by a process instance. WS-BPEL does not make any assumptions about the WSDL binding. Constraints, ambiguities, provided or missing capabilities of WSDL bindings are out of scope of this specification.
However, the abstract part of WSDL does not define the constraints imposed on the communication patterns supported by the concrete bindings. Therefore a WS-BPEL process may define behavior relative to a partner service that is not supported by all possible bindings, and it may happen that some bindings are invalid for a WS-BPEL process definition.
While WS-BPEL attempts to provide as much compatibility with WSDL 1.1 as possible there are three areas where such compatibility is not feasible.
· Fault naming with its restriction, as discussed later in this document (see section 12.5. Fault Handlers)
· [SA00002] Overloaded operation names in WSDL port types. Regardless of whether the WS-I Basic Profile configuration is enabled, a WS-BPEL processor MUST reject any WSDL port type definition that includes overloaded operation names. This restriction was deemed appropriate as overloaded operations are rare, they are actually banned in the WS-I Basic Profile and supporting them was felt to introduce more complexity than benefit.
· [SA00001] Port types that contain solicit-response or notification operations as defined in the WSDL 1.1 specification. Regardless of whether the WS-I Basic Profile configuration is enabled, a WS-BPEL processor MUST reject a WS-BPEL that refers to such port types.
At the time this specification was completed, various Web Service standards work, such as WSDL 2.0 and WS-Addressing, were ongoing and not ready for consideration for WS-BPEL 2.0. Future versions of WS-BPEL may provide support for these standards.
It should be noted that the examples provided in this specification adopt the Schema at location "http://schemas.xmlsoap.org/wsdl/2004-08-24.xsd" for the namespace URI http://schemas.xmlsoap.org/wsdl/ [WSDL 1.1]. This XML Schema incorporates fixes for known errors, and is the XML Schema selected by the [WS-I Basic Profile 1.1 Errata] (October 25, 2005).
4. Static Analysis of a Business Process
WS-BPEL takes it as a general principle that conformant implementations MUST perform basic static analysis listed in Appendix B. Static Analysis requirement summary (Non-Normative) to detect and reject process definitions that fail any of those static analysis check. Please note that such analysis might in some cases prevent the use of processes that would not, in fact, create situations with errors, either in specific uses or in any use. For example, a WS-BPEL implementation will reject a process with <invoke> activity referring to an undefined variable, where the <invoke> activity may not be actually reached during execution of the process.
A WS-BPEL implementation MAY perform extra static analysis checking beyond the basic static analysis required by this specification to signal warnings or even reject process definitions. Such an implementation SHOULD be configurable to disable these non-specified static analysis checks.
5. Defining a Business Process
5.1. Initial Example
Before describing the structure of business processes in detail, this section presents a simple example of a WS-BPEL process for handling a purchase order. The aim is to introduce the most basic structures and some of the fundamental concepts of the language.
The operation of the process is very simple, and is represented in Error! Reference source not found.. Dotted lines represent sequencing. Free grouping of sequences represents concurrent sequences. Solid arrows represent control links used for synchronization across concurrent activities. Note that this is not meant to be a definitive graphical notation for WS-BPEL processes. It is used here informally as an aid to understanding.
On receiving the purchase order from a customer, the process initiates three paths concurrently: calculating the final price for the order, selecting a shipper, and scheduling the production and shipment for the order. While some of the processing can proceed concurrently, there are control and data dependencies between the three paths. In particular, the shipping price is required to finalize the price calculation, and the shipping date is required for the complete fulfillment schedule. When the three concurrent paths are completed, invoice processing can proceed and the invoice is sent to the customer.
The WSDL port type offered by the service to its customers (purchaseOrderPT) is shown in
the following WSDL document. Other WSDL definitions required by the business
process are included in the same WSDL document for simplicity; in particular,
the port types for the Web Services providing price calculation, shipping
selection and scheduling, and production scheduling functions are also defined
there. Observe that there are no bindings or service elements in the WSDL
document. A WS-BPEL process is defined by referencing only the port types of
the services involved in the process, and not their possible deployments.
Defining business processes in this way allows the reuse of business process
definitions over multiple deployments of compatible services.
The <partnerLinkType>s included at the bottom of the WSDL document represent the interaction
between the purchase order service and each of the parties with which it
interacts (see section 6. Partner Link Types, Partner Links, and Endpoint
References). <PartnerLinkType>s can be used to represent dependencies between services, regardless of
whether a WS-BPEL business process is defined for one or more of those
services. Each <partnerLinkType> defines up to two "role" names, and lists the port types
that each role must support for the interaction to be carried out successfully.
In this example, two <partnerLinkType>s, "purchasingLT" and "schedulingLT", list a single
role because, in the corresponding service interactions, one of the parties
provides all the invoked operations: The "purchasingLT" <partnerLinkType>
represents the connection between the process and the requesting customer,
where only the purchase order service needs to offers a service operation
("sendPurchaseOrder"); the "schedulingLT" <partnerLinkType>
represents the interaction between the purchase order service and the
scheduling service, in which only operations of the latter are invoked. The two
other <partnerLinkType>s, "invoicingLT" and "shippingLT", define two roles because both the user of the invoice
calculation and the user of the shipping service (the invoice or the shipping
schedule) must provide callback operations to enable notifications 
to be sent ("invoiceCallbackPT" and "shippingCallbackPT" port types).
<wsdl:definitions
targetNamespace="http://manufacturing.org/wsdl/purchase"
xmlns:sns="http://manufacturing.org/xsd/purchase"
xmlns:pos="http://manufacturing.org/wsdl/purchase"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:plnk="http://schemas.xmlsoap.org/ws/2004/03/partner-link/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<wsdl:types>
<xsd:schema>
<xsd:import namespace="http://manufacturing.org/xsd/purchase"
schemaLocation="http://manufacturing.org/xsd/purchase.xsd" />
</xsd:schema>
</wsdl:types>
<wsdl:message name="POMessage">
<wsdl:part name="customerInfo" type="sns:customerInfoType" />
<wsdl:part name="purchaseOrder" type="sns:purchaseOrderType" />
</wsdl:message>
<wsdl:message name="InvMessage">
<wsdl:part name="IVC" type="sns:InvoiceType" />
</wsdl:message>
<wsdl:message name="orderFaultType">
<wsdl:part name="problemInfo" element=”sns:OrderFault " />
</wsdl:message>
<wsdl:message name="shippingRequestMessage">
<wsdl:part name="customerInfo" element="sns:customerInfo" />
</wsdl:message>
<wsdl:message name="shippingInfoMessage">
<wsdl:part name="shippingInfo" element="sns:shippingInfo" />
</wsdl:message>
<wsdl:message name="scheduleMessage">
<wsdl:part name="schedule" element="sns:scheduleInfo" />
</wsdl:message>
<!-- portTypes supported by the purchase order process -->
<wsdl:portType name="purchaseOrderPT">
<wsdl:operation name="sendPurchaseOrder">
<wsdl:input message="pos:POMessage" />
<wsdl:output message="pos:InvMessage" />
<wsdl:fault name="cannotCompleteOrder"
message="pos:orderFaultType" />
</wsdl:operation>
</wsdl:portType>
<wsdl:portType name="invoiceCallbackPT">
<wsdl:operation name="sendInvoice">
<wsdl:input message="pos:InvMessage" />
</wsdl:operation>
</wsdl:portType>
<wsdl:portType name="shippingCallbackPT">
<wsdl:operation name="sendSchedule">
<wsdl:input message="pos:scheduleMessage" />
</wsdl:operation>
</wsdl:portType>
<!-- portType supported by the invoice services -->
<wsdl:portType name="computePricePT">
<wsdl:operation name="initiatePriceCalculation">
<wsdl:input message="pos:POMessage" />
</wsdl:operation>
<wsdl:operation name="sendShippingPrice">
<wsdl:input message="pos:shippingInfoMessage" />
</wsdl:operation>
</wsdl:portType>
<!-- portType supported by the shipping service -->
<wsdl:portType name="shippingPT">
<wsdl:operation name="requestShipping">
<wsdl:input message="pos:shippingRequestMessage" />
<wsdl:output message="pos:shippingInfoMessage" />
<wsdl:fault name="cannotCompleteOrder"
message="pos:orderFaultType" />
</wsdl:operation>
</wsdl:portType>
<!-- portType supported by the production scheduling process -->
<wsdl:portType name="schedulingPT">
<wsdl:operation name="requestProductionScheduling">
<wsdl:input message="pos:POMessage" />
</wsdl:operation>
<wsdl:operation name="sendShipingSchedule">
<wsdl:input message="pos:scheduleMessage" />
</wsdl:operation>
</wsdl:portType>
<plnk:partnerLinkType name="purchasingLT">
<plnk:role name="purchaseService"
portType="pos:purchaseOrderPT" />
</plnk:partnerLinkType>
<plnk:partnerLinkType name="invoicingLT">
<plnk:role name="invoiceService"
portType="pos:computePricePT" />
<plnk:role name="invoiceRequester"
portType="pos:invoiceCallbackPT" />
</plnk:partnerLinkType>
<plnk:partnerLinkType name="shippingLT">
<plnk:role name="shippingService"
portType="pos:shippingPT" />
<plnk:role name="shippingRequester"
portType="pos:shippingCallbackPT" />
</plnk:partnerLinkType>
<plnk:partnerLinkType name="schedulingLT">
<plnk:role name="schedulingService"
portType="pos:schedulingPT" />
</plnk:partnerLinkType>
</wsdl:definitions>
The business process for the order service is defined next. There are four major sections in this process definition. Note that the example provides a simple case. In order to complete it, additional elements may be needed such as <correlationSets>.
· The <partnerLinks> section defines the different parties that interact with the business process in the course of processing the order. The four <partnerLink> definitions shown here correspond to the sender of the order (customer), as well as the providers of price (invoicing provider), shipment (shipping provider), and manufacturing scheduling services (scheduling provider). Each <partnerLink> is characterized by a partnerLinkType and either one or two role names. This information identifies the functionality that must be provided by the business process and by the partner service for the relationship to succeed, that is, the port types that the purchase order process and the partner need to implement.
· The <variables> section defines the data variables used by the process, providing their definitions in terms of WSDL message types, XML Schema types (simple or complex), or XML Schema elements. Variables allow processes to maintain state between message exchanges.
· The <faultHandlers> section contains fault handlers defining the activities that must be performed in response to faults resulting from the invocation of the assessment and approval services. In WS-BPEL, all faults, whether internal or resulting from a service invocation, are identified by a qualified name. In particular, each WSDL fault is identified in WS-BPEL by a qualified name formed by the target namespace of the WSDL document in which the relevant port type and fault are defined, and the NCName of the fault.
· The rest of the <process> definition contains the description of the normal behavior for handling a purchase request. The major elements of this description are explained in the section following the process definition.
<process name="purchaseOrderProcess"
targetNamespace="http://example.com/ws-bp/purchase"
xmlns="http://schemas.xmlsoap.org/ws/2004/03/business-process/"
xmlns:lns="http://manufacturing.org/wsdl/purchase">
<documentation xml:lang="EN">
A simple example of a WS-BPEL process for handling a purchase
order.
</documentation>
<partnerLinks>
<partnerLink name="purchasing"
partnerLinkType="lns:purchasingLT" myRole="purchaseService" />
<partnerLink name="invoicing" partnerLinkType="lns:invoicingLT"
myRole="invoiceRequester" partnerRole="invoiceService" />
<partnerLink name="shipping" partnerLinkType="lns:shippingLT"
myRole="shippingRequester" partnerRole="shippingService" />
<partnerLink name="scheduling"
partnerLinkType="lns:schedulingLT"
partnerRole="schedulingService" />
</partnerLinks>
<variables>
<variable name="PO" messageType="lns:POMessage" />
<variable name="Invoice" messageType="lns:InvMessage" />
<variable name="shippingRequest"
messageType="lns:shippingRequestMessage" />
<variable name="shippingInfo"
messageType="lns:shippingInfoMessage" />
<variable name="shippingSchedule"
messageType="lns:scheduleMessage" />
</variables>
<faultHandlers>
<catch faultName="lns:cannotCompleteOrder"
faultVariable="POFault"
faultMessageType="lns:orderFaultType">
<reply partnerLink="purchasing"
portType="lns:purchaseOrderPT"
operation="sendPurchaseOrder" variable="POFault"
faultName="cannotCompleteOrder" />
</catch>
</faultHandlers>
<sequence>
<receive partnerLink="purchasing" portType="lns:purchaseOrderPT"
operation="sendPurchaseOrder" variable="PO"
createInstance="yes">
<documentation>Receive Purchase Order</documentation>
</receive>
<flow>
<documentation>
A parallel flow to handle shipping, invoicing and
scheduling
</documentation>
<links>
<link name="ship-to-invoice" />
<link name="ship-to-scheduling" />
</links>
<sequence>
<assign>
<copy>
<from>$PO.customerInfo</from>
<to>$shippingRequest.customerInfo</to>
</copy>
</assign>
<invoke partnerLink="shipping" portType="lns:shippingPT"
operation="requestShipping"
inputVariable="shippingRequest"
outputVariable="shippingInfo">
<documentation>Decide On Shipper</documentation>
<sources>
<source linkName="ship-to-invoice" />
</sources>
</invoke>
<receive partnerLink="shipping"
portType="lns:shippingCallbackPT"
operation="sendSchedule" variable="shippingSchedule">
<documentation>Arrange Logistics</documentation>
<sources>
<source linkName="ship-to-scheduling" />
</sources>
</receive>
</sequence>
<sequence>
<invoke partnerLink="invoicing"
portType="lns:computePricePT"
operation="initiatePriceCalculation"
inputVariable="PO">
<documentation>
Initial Price Calculation
</documentation>
</invoke>
<invoke partnerLink="invoicing"
portType="lns:computePricePT"
operation="sendShippingPrice"
inputVariable="shippingInfo">
<documentation>
Complete Price Calculation
</documentation>
<targets>
<target linkName="ship-to-invoice" />
</targets>
</invoke>
<receive partnerLink="invoicing"
portType="lns:invoiceCallbackPT"
operation="sendInvoice" variable="Invoice" />
</sequence>
<sequence>
<invoke partnerLink="scheduling"
portType="lns:schedulingPT"
operation="requestProductionScheduling"
inputVariable="PO">
<documentation>
Initiate Production Scheduling
</documentation>
</invoke>
<invoke partnerLink="scheduling"
portType="lns:schedulingPT"
operation="sendShippingSchedule"
inputVariable="shippingSchedule">
<documentation>
Complete Production Scheduling
</documentation>
<targets>
<target linkName="ship-to-scheduling" />
</targets>
</invoke>
</sequence>
</flow>
<reply partnerLink="purchasing" portType="lns:purchaseOrderPT"
operation="sendPurchaseOrder" variable="Invoice">
<documentation>Invoice Processing</documentation>
</reply>
</sequence>
</process>
5.2. The Structure of a Business Process
This section provides a quick summary of the WS-BPEL syntax. It provides only a brief overview; the details of each language construct are described in the rest of this document.
The basic structure of the language is:
<process name="NCName" targetNamespace="anyURI"
queryLanguage="anyURI"?
expressionLanguage="anyURI"?
suppressJoinFailure="yes|no"?
exitOnStandardFault="yes|no"?
xmlns="http://schemas.xmlsoap.org/ws/2004/03/business-process/">
<import namespace="anyURI"?
location="anyURI"?
importType="anyURI" />*
<extensions>?
<extension namespace="anyURI" mustUnderstand="yes|no" />*
</extensions>
<partnerLinks>?
<!-- Note: At least one role must be specified. -->
<partnerLink name="NCName"
partnerLinkType="QName"
myRole="NCName"?
partnerRole="NCName"?
initializePartnerRole="yes|no"?>+
</partnerLink>
</partnerLinks>
<messageExchanges>?
<messageExchange name="NCName" />+
</messageExchanges>
<variables>?
<variable name="BPELVariableName"
messageType="QName"?
type="QName"?
element="QName"? />+
</variables>
<correlationSets>?
<correlationSet name="NCName" properties="QName-list" />+
</correlationSets>
<faultHandlers>?
<!-- Note: There must be at least one faultHandler -->
<catch faultName="QName"?
faultVariable="BPELVariableName"?
( faultMessageType="QName" | faultElement="QName" )? >*
activity
</catch>
<catchAll>?
activity
</catchAll>
</faultHandlers>
<eventHandlers>?
<!-- Note: There must be at least one onEvent or onAlarm. -->
<onEvent partnerLink="NCName"
portType="QName"?
operation="NCName"
( messageType="QName" | element="QName" )?
variable="BPELVariableName"?
messageExchange="NCName"?>*
<correlations>?
<correlation set="NCName" initiate="yes|join|no"? />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
<scope ...>...</scope>
</onEvent>
<onAlarm>*
<!-- Note: There must be at least one expression. -->
(
<for expressionLanguage="anyURI"?>duration-expr</for>
|
<until expressionLanguage="anyURI"?>deadline-expr</until>
)?
<repeatEvery expressionLanguage="anyURI"?>
duration-expr
</repeatEvery>?
<scope ...>...</scope>
</onAlarm>
</eventHandlers>
activity
</process>
The top-level attributes are as follows:
· queryLanguage. This attribute specifies the query language used in the process for selection of nodes in assignment, property definition, etc. The default value for this attribute is: "urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0", which represents the usage of [XPath 1.0] within WS-BPEL 2.0.
· expressionLanguage. This attribute specifies the expression language used in the <process>. The default value for this attribute is: "urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0", which represents the usage of [XPath 1.0] within WS-BPEL 2.0.
· suppressJoinFailure. This attribute determines whether the joinFailure fault will be suppressed for all activities in the process. The effect of the attribute at the process level can be overridden by an activity using a different value for the attribute. The default for this attribute is "no" at the process level. When this attribute is not specified for an activity, it inherits its value from its closest enclosing activity or from the <process> if no enclosing activity specifies this attribute.
· exitOnStandardFault. If the value of this attribute is set to “yes”, then the process MUST exit immediately as if an <exit> activity has been reached, when a WS-BPEL standard fault other than bpel:joinFailure is encountered[1]. If the value of this attribute is set to “no”, then the process can handle a standard fault using a fault handler. The default value for this attribute is “no”. When this attribute is not specified on a <scope> it inherits its value from its enclosing <scope> or <process>.
[SA00003] If the value of exitOnStandardFault of a <scope> or <process> is set to “yes”, then a fault handler that explicitly targets the WS-BPEL standard faults MUST NOT be used in that scope. A process definition that violates this condition MUST be detected by static analysis and MUST be rejected by a conformant implementation.
· The syntax of Abstract Process has its own distinct target namespace. Additional top-level attributes are defined for Abstract Processes.
The value of the queryLanguage and expressionLanguage attributes on the <process> element are global defaults and can be overridden on specific constructs, such as <condition> of a <while> activity, as defined later in this specification. In addition, the queryLanguage attribute is also available for use in defining WS-BPEL <propertyAlias>es in WSDL. WS-BPEL processors MUST:
· statically determine which languages are referenced by queryLanguage or expressionLanguage attributes either in the WS-BPEL process definition itself or in any WS-BPEL property definitions in associated WSDLs and
· [SA00004] if any referenced language is unsupported by the WS-BPEL processor then the processor MUST reject the submitted WS-BPEL process definition.
Note that: <documentation> construct may be added to virtually all WS-BPEL constructs as the formal way to annotate processes definition with human documentation. Examples of <documentation> construct can be found in the previous sections. Detailed description of <documention> is provided in the next section 5.3. Language Extensibility.
Each business process has one main activity.
A WS-BPEL activity can be any of the following:
· <receive>
· <reply>
· <invoke>
· <assign>
· <throw>
· <exit>
· <wait>
· <empty>
· <sequence>
· <if>
· <while>
· <repeatUntil>
· <forEach>
· <pick>
· <flow>
· <scope>
· <compensate>
· <compensateScope>
· <rethrow>
· <validate>
· <extensionActivity>
The syntax of each of these elements is described in the following paragraphs.
The <receive> activity allows the business process to wait for a matching message to arrive. The <receive> activity completes when the message arrives. The portType attribute on the <receive> activity is optional. [SA00005] If the portType attribute is included for readability, the value of the portType attribute MUST match the portType value implied by the combination of the specified partnerLink and the role implicitly specified by the activity (see also partnerLink description in the next section). The optional messageExchange attribute is used to associate a <reply> activity with a <receive> activity.
<receive partnerLink="NCName"
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
createInstance="yes|no"?
messageExchange="NCName"?
standard-attributes>
standard-elements
<correlations>?
<correlation set="NCName" initiate="yes|join|no"? />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
</receive>
The <reply> activity allows the business process to send a message in reply to a message that was received by an inbound message activity (IMA), that is, <receive>, <onMessage>, or <onEvent>. The combination of an IMA and a <reply> forms a request-response operation on a WSDL portType for the process. The portType attribute on the <reply> activity is optional. If the portType attribute is included for readability, the value of the portType attribute MUST match the portType value implied by the combination of the specified partnerLink and the role implicitly specified by the activity (see also partnerLink description in the next section). The optional messageExchange attribute is used to associate a <reply> activity with an IMA.
<reply partnerLink="NCName"
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
faultName="QName"?
messageExchange="NCName"?
standard-attributes>
standard-elements
<correlations>?
<correlation set="NCName" initiate="yes|join|no"? />+
</correlations>
<toParts>?
<toPart part="NCName" fromVariable="BPELVariableName" />+
</toParts>
</reply>
The <invoke> activity allows the business process to invoke a one-way or request-response operation on a portType offered by a partner. In the request-response case, the invoke activity completes when the response is received. The portType attribute on the <invoke> activity is optional. If the portType attribute is included for readability, the value of the portType attribute MUST match the portType value implied by the combination of the specified partnerLink and the role implicitly specified by the activity (see also partnerLink description in the next section).
<invoke partnerLink="NCName"
portType="QName"?
operation="NCName"
inputVariable="BPELVariableName"?
outputVariable="BPELVariableName"?
standard-attributes>
standard-elements
<correlations>?
<correlation set="NCName" initiate="yes|join|no"?
pattern="request|response|request-response"? />+
</correlations>
<catch faultName="QName"?
faultVariable="BPELVariableName"?
faultMessageType="QName"?
faultElement="QName"?>*
activity
</catch>
<catchAll>?
activity
</catchAll>
<compensationHandler>?
activity
</compensationHandler>
<toParts>?
<toPart part="NCName" fromVariable="BPELVariableName" />+
</toParts>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
</invoke>
The <assign> activity is used to update the values of variables with new data. An <assign> construct can contain any number of elementary assignments, including <copy> assign elements or data update operations defined as extension under other namespaces.
<assign validate="yes|no"? standard-attributes>
standard-elements
(
<copy>
from-spec
to-spec
</copy>
|
<extensionAssignOperation>
assign-element-of-other-namespace
</extensionAssignOperation>
)+
</assign>
The <validate> activity is used to validate the values of variables against their associated XML and WSDL data definition. The construct has a variables attribute, which points to the variables being validated.
<validate variables="BPELVariableName-list" standard-attributes>
standard-elements
</validate>
The <throw> activity is used to generate a fault from inside the business process.
<throw faultName="QName"
faultVariable="BPELVariableName"?
standard-attributes>
standard-elements
</throw>
The <wait> activity is used to wait for a given time period or until a certain point in time has been reached. Exactly one of the expiration criteria MUST be specified.
<wait standard-attributes>
standard-elements
(
<for expressionLanguage="anyURI"?>duration-expr</for>
|
<until expressionLanguage="anyURI"?>deadline-expr</until>
)
</wait>
The <empty> activity is a "no-op" in a business process. This is useful for synchronization of concurrent activities, for instance.
<empty standard-attributes>
standard-elements
</empty>
The <sequence> activity is used to define a collection of activities to be performed sequentially in lexical order.
<sequence standard-attributes>
standard-elements
activity+
</sequence>
The <if> activity is used to select exactly one activity for execution from a set of choices.
<if standard-attributes>
standard-elements
<condition expressionLanguage="anyURI"?>bool-expr</condition>
activity
<elseif>*
<condition expressionLanguage="anyURI"?>bool-expr</condition>
activity
</elseif>
<else>?
activity
</else>
</if>
The <while> activity is used to define that the child activity is to be repeated as long as the specified <condition> is true.
<while standard-attributes>
standard-elements
<condition expressionLanguage="anyURI"?>bool-expr</condition>
activity
</while>
The <repeatUntil> activity is used to define that the child activity is to be repeated until the specified <condition> becomes true. The <condition> is tested after the child activity completes. The <repeatUntil> activity is used to execute the child activity at least once.
<repeatUntil standard-attributes>
standard-elements
activity
<condition expressionLanguage="anyURI"?>bool-expr</condition>
</repeatUntil>
The <forEach> activity iterates its child scope activity exactly N+1 times where N equals the <finalCounterValue> minus the <startCounterValue>. If parallel="yes" then this is a parallel <forEach> where the N+1 instances of the enclosed <scope> activity SHOULD occur in parallel. In essence an implicit flow is dynamically created with N+1 copies of the <forEach>'s <scope> activity as children. A <completionCondition> may be used within the <forEach> to allow the <forEach> activity to complete without executing or finishing all the branches specified.
<forEach counterName="BPELVariableName" parallel="yes|no"
standard-attributes>
standard-elements
<startCounterValue expressionLanguage="anyURI"?>
unsigned-integer-expression
</startCounterValue>
<finalCounterValue expressionLanguage="anyURI"?>
unsigned-integer-expression
</finalCounterValue>
<completionCondition>?
<branches expressionLanguage="anyURI"?
successfulBranchesOnly="yes|no"?>
unsigned-integer-expression
</branches>
</completionCondition>
<scope ...>...</scope>
</forEach>
The <pick> activity is used to wait for one of several possible messages to arrive or for a time-out to occur. When one of these triggers occurs, the associated child activity is performed. When the child activity completes then the <pick> activity completes.
The portType attribute on the <onMessage> activity is optional. If the portType attribute is included for readability, the value of the portType attribute MUST match the portType value implied by the combination of the specified partnerLink and the role implicitly specified by the activity. The optional messageExchange attribute is used to associate a <reply> activity with a <onMessage> activity.
<pick createInstance="yes|no"? standard-attributes>
standard-elements
<onMessage partnerLink="NCName"
portType="QName"?
operation="NCName"
variable="BPELVariableName"?
messageExchange="NCName"?>+
<correlations>?
<correlation set="NCName" initiate="yes|join|no"? />+
</correlations>
<fromParts>?
<fromPart part="NCName" toVariable="BPELVariableName" />+
</fromParts>
activity
</onMessage>
<onAlarm>*
(
<for expressionLanguage="anyURI"?>duration-expr</for>
|
<until expressionLanguage="anyURI"?>deadline-expr</until>
)
activity
</onAlarm>
</pick>
The <flow> activity is used to specify one or more activities to be performed concurrently. <links> can be used within a <flow> to define explicit control dependencies between nested child activites.
<flow standard-attributes>
standard-elements
<links>?
<link name="NCName" />+
</links>
activity+
</flow>
The <scope> activity is used to define a nested activity with its own associated <partnerLinks>, <messageExchanges>, <variables>, <correlationSets>, <faultHandlers>, <compensationHandler>, <terminationHandler>, and <eventHandlers>.
<scope isolated="yes|no"? exitOnStandardFault="yes|no"?
standard-attributes>
standard-elements
<partnerLinks>?
... see above under <process> for syntax ...
</partnerLinks>
<messageExchanges>?
... see above under <process> for syntax ...
</messageExchanges>
<variables>?
... see above under <process> for syntax ...
</variables>
<correlationSets>?
... see above under <process> for syntax ...
</correlationSets>
<faultHandlers>?
... see above under <process> for syntax ...
</faultHandlers>
<compensationHandler>?
...
</compensationHandler>
<terminationHandler>?
...
</terminationHandler>
<eventHandlers>?
... see above under <process> for syntax ...
</eventHandlers>
activity
</scope>
The <compensateScope> activity is used to start compensation on a specified inner scope that has already completed successfully. [SA00007] This activity MUST only be used from within a fault handler, another compensation handler, or a termination handler.
<compensateScope target="NCName" standard-attributes>
standard-elements
</compensateScope>
The <compensate> activity is used to start compensation on all inner scopes that have already completed successfully, in default order. [SA00008] This activity MUST only be used from within a fault handler, another compensation handler, or a termination handler.
<compensate standard-attributes>
standard-elements
</compensate>
The <exit> activity is used to immediately end a business process instance within which the <exit> activity is contained.
<exit standard-attributes>
standard-elements
</exit>
The <rethrow> activity is used to rethrow the fault that was originally caught by the immediately enclosing fault handler. [SA00006] The <rethrow> activity MUST only be used within a fault handler (i.e. <catch> and <catchAll> elements). This syntactic constraint MUST be statically enforced.
<rethrow standard-attributes>
standard-elements
</rethrow>
The <extensionActivity> element is used to extend WS-BPEL by introducing a new activity type. The contents of an <extensionActivity> element MUST be a single element that MUST make available WS-BPEL's standard-attributes and standard-elements.
<extensionActivity>
<anyElementQName standard-attributes>
standard-elements
</anyElementQName>
</extensionActivity>
The "standard-attributes" referenced above are:
name="NCName"? suppressJoinFailure="yes|no"?
where the default values are as follows:
· name: No default value (that is, the default is unnamed)
· suppressJoinFailure: When this attribute is not specified for an activity, it inherits its value from its closest enclosing activity or from the process if no enclosing activity specifies this attribute.
The "standard-elements" referenced above are:
<targets>?
<joinCondition expressionLanguage="anyURI"?>?
bool-expr
</joinCondition>
<target linkName="NCName" />+
</targets>
<sources>?
<source linkName="NCName">+
<transitionCondition expressionLanguage="anyURI"?>?
bool-expr
</transitionCondition>
</source>
</sources>
5.3. Language Extensibility
WS-BPEL supports extensibility by allowing namespace-qualified attributes to appear on any WS-BPEL element and by allowing elements from other namespaces to appear within WS-BPEL defined elements. This is allowed in the XML Schema specifications for WS-BPEL.
Extensions are either mandatory or optional (see section 14. Extension Declarations). [SA00009] In the case of mandatory extensions not supported by a WS-BPEL implementation, the process definition MUST be rejected. Optional extensions not supported by a WS-BPEL implementation MUST be ignored.
In addition, WS-BPEL provides two explicit extension constructs: <extensionAssignOperation> and <extensionActivity>. Specific rules for these constructs are described in sections 8.4. Assignment and 10.9. Adding new Activity Types – ExtensionActivity.
Extensions MUST NOT contradict the semantics of any element or attribute defined by the WS-BPEL specification.
Extensions are allowed in WS-BPEL constructs used in WSDL definitions, such as <partnerLinkType>, <role>, <property> and <propertyAlias>. The same syntax pattern and semantic rules for extensions of WS-BPEL constructs are applied to these extensions as well. For the WSDL definitions transitively referenced by a WS-BPEL process, extension declaration directives of this WS-BPEL process are applied to all extensions used in WS-BPEL constructs in these WSDL definitions (see section 14. Extension Declarations).
The optional <documentation> construct is applicable to any WS-BPEL extensible construct. Typically, the contents of <documentation> are for human targeted annotation. Example types for those content are: plain text, HTML and XHTML. Tool-implementation specific information (e.g. the graphical layout details) should be added through elements and attributes of other namespaces, using the general WS-BPEL extensibility mechanisms.
5.4. Document Linking
A WS-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, variable 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.
<import namespace="anyURI"?
location="anyURI"?
importType="anyURI" />*
The <import> element is used within a WS-BPEL process to declare 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 one mandatory and two optional attributes.
· namespace. The namespace attribute specifies an absolute URI that identifies the imported definitions. This attribute is optional. An import element without a namespace attribute indicates that external definitions are in use which are not namespace qualified. [SA00011] If a namespace is specified then the imported definitions MUST be in that namespace. [SA00012] If no namespace is specified then the imported definitions MUST NOT contain a targetNamespace specification. If either of these rules are not met then the process definition MUST be rejected by a conforming WS-BPEL implementation. The namespace http://www.w3.org/2001/XMLSchema is imported implicitly. Note, however, that there is no implicit XML Namespace prefix defined for http://www.w3.org/2001/XMLSchema.
· location. The location attribute contains a URI indicating the location of a document that contains relevant definitions. The location URI may be a relative URI, following the usual rules for resolution of the URI base (XML Base and RFC 2396). The location attribute is optional. An <import> element without a location attribute indicates that external definitions are used by the process but makes no statement about where those definitions may be found. The location attribute is a hint and a WS-BPEL processor is not required to retrieve the document being imported from the specified location.
· importType. The mandatory importType attribute identifies the type of document being imported by providing an absolute URI that identifies the encoding language used in the document. [SA00013] The value of the importType attribute 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. Other importType URI values MAY be used here.
Observe that according to these rules, it is permissible to have an <import> element without namespace and location attributes, and only containing an importType attribute. Such an <import> element indicates that external definitions of the indicated type are in use which are not namespace qualified, and makes no statement about where those definitions may be found.
[SA00010] A WS-BPEL process definition MUST import all XML Schema and WSDL definitions it uses. This includes all XML Schema type and element definitions, all WSDL port types and message types as well as <property> and <propertyAlias> definitions used by the process. [SA00053], [SA00054] A WS-BPEL processor MUST verify that all message parts referenced by a <propertyAlias>, <from>, <to>, <fromPart>, and <toPart> are found in their respective WSDL message definitions. In order to support the use of definitions from namespaces spanning multiple documents, a WS-BPEL process MAY include more than one import declaration for the same namespace and importType, provided that those declarations include different location values. <import> elements are conceptually unordered. [SA00014] A WS-BPEL process definition MUST be rejected if the imported documents contain conflicting definitions of a component used by the importing process definition (as could be caused, for example, when the XSD redefinition mechanism is used).
Schema definitions defined in the types section of a WSDL document which is imported by a WS-BPEL process definition are considered to be effectively imported themselves and are available to the process for the purpose of defining XML Schema variables. However, documents (or namespaces) imported by an imported document (or namespace) MUST NOT be transitively imported by the WS-BPEL processor. In particular, this means that if an external item is used by a WS-BPEL process, then a document (or namespace) that defines that item MUST be directly imported by the process; observe however that this requirement does not limit the ability of the imported document itself to import other documents or namespaces. The following example clarifies some of the issues related to the lack of transitivity of imports.
Assume a document D1 defines a type called d1:Type. However, d1:Type's definition could depend on another type called d2:Type which is defined in document D2. D1 could include an import for D2 thus making d2:Type's definition available for use within the definition of d1:Type. If a WS-BPEL process refers to d1:Type it must import document D1. By importing D1 the WS-BPEL process can legally refer to d1:Type. But the WS-BPEL process could not refer to d2:Type even though D1 imports D2. This is because transitivity of import is not supported by WS-BPEL. Note, however, that D1 can still import D2 and d1:Type can still use d2:Type in its definition. In order to allow the WS-BPEL process to refer to d2:Type it would be necessary for the WS-BPEL process to directly import document D2.
5.5. The Lifecycle of an Executable Business Process
As noted in the introduction, the interaction model that is directly supported by WSDL is essentially a stateless client-server model of request-response or uncorrelated one-way interactions. WS-BPEL, builds on WSDL by assuming that all external interactions of the business process occur through Web Service operations. However, WS-BPEL business processes represent stateful long-running interactions in which each interaction has a beginning, defined behavior during its lifetime, and an end. For example, in a supply chain, a seller's business process might offer a service that begins an interaction by accepting a purchase order through an input message, and then returns an acknowledgement to the buyer if the order can be fulfilled. It might later send further messages to the buyer, such as shipping notices and invoices. The seller's business process remembers the state of each such purchase order interaction separately from other similar interactions. This is necessary because a buyer might be carrying on many simultaneous purchase processes with the same seller. In short, a WS-BPEL business process definition can be thought of as a template for creating business process instances.
The creation of a process instance in WS-BPEL is always implicit; activities that receive messages (that is, <receive> activities and <pick> activities) can be annotated to indicate that the occurrence of that activity causes a new instance of the business process to be created. This is done by setting the createInstance attribute of such an activity to "yes". When a message is received by such an activity, an instance of the business process is created if it does not already exist (see sections 10.4. Providing Web Service Operations – Receive and Reply and 11.5. Selective Event Processing – Pick).
A start activity is a <receive> or a <pick> activity annotated with a createInstance="yes" attribute. [SA00015] Each executable business process MUST contain at least one start activity (see section 10.4. Providing Web Service Operations – Receive and Reply for more details on start activities).
If more than one start activity exists in a process and these start activities contain <correlations> then all such activities MUST share at least one common <correlation> (see the example in section 9.2. Declaring and Using Correlation Sets).
If a process contains exactly one start activity then the use of <correlationSets> is unconstrained. This includes a pick with multiple <onMessage> branches; each such branch can use different <correlationSets> or no <correlationSets>.
A business process instance ends either normally or abnormally. The process ends normally when the main activity of the process completes. The process ends abnormally if either:
· a fault reaches the process scope, regardless of whether it is handled or not (see section 10.10. Immediately Ending a Process – Exit), or
· the process instance is explicitly ended by an exit activity (see section 10.10. Immediately Ending a Process).
5.6. Revisiting the Initial Example
In the purchaseOrderProcess example in section 5.1. Initial Example, the structure of the main activity of the process is defined by the outer <sequence> element, which states that the three activities contained inside are performed in order. The customer request is received (<receive> element), then processed (inside a <flow> section that enables concurrent behavior), and a reply message with the final approval status of the request is sent back to the customer (<reply>). Note that the <receive> and <reply> elements are matched respectively to the <input> and <output> messages of the "sendPurchaseOrder" operation invoked by the customer, while the activities performed by the process between these elements represent the actions taken in response to the customer request, from the time the request is received to the time the response is sent back (reply).
The processing taking place inside the <flow> element consists of three concurrent <sequence> activities. The synchronization dependencies between activities in the three concurrent sequences are expressed by using <links> to connect them. The <links> are defined inside the <flow> and are used to connect a source activity to a target activity. Note that each activity declares itself as the source or target of a <link> by using the nested <source> and <target> elements. In the absence of <links>, the activities nested directly inside a <flow> proceed concurrently. In the example, however, the presence of two <link>s introduces control dependencies between the activities performed inside each sequence. For example, while the price calculation can be started immediately after the request is received, shipping price can only be added to the invoice after the shipper information has been obtained; this dependency is represented by the <link> (named "ship-to-invoice") that connects the first call on the shipping provider ("requestShipping") with sending shipping information to the price calculation service ("sendShippingPrice"). Likewise, shipping scheduling information can only be sent to the manufacturing scheduling service after it has been received from the shipper service; thus the need for the second <link> ("ship-to-scheduling").
Data is shared between different activities through shared variables, for example, the two <variable>s "shippingInfo" and "shippingSchedule".
Certain operations can return faults, as defined in their WSDL definitions. For simplicity, it is assumed here that the two operations return the same fault ("cannotCompleteOrder"). When a fault occurs, normal processing is terminated and control is transferred to the corresponding fault handler, as defined in the <faultHandlers> section. In this example the fault handler uses a <reply> element to return a fault to the customer (note the faultName attribute in the <reply> element).
Finally, it is important to observe how an assignment activity is used to transfer information between data variables. The simple assignments shown in this example transfer a message part from a source variable to a message part in a target variable, but more complex forms of assignments are also possible.
6. Partner Link Types, Partner Links, and Endpoint References
An important use case for WS-BPEL is describing cross enterprise business interactions in which the business processes of each enterprise interact through Web Service interfaces. Therefore, WS-BPEL provides the ability to model the required relationships between partner processes. WSDL already describes the functionality of a service provided by a partner, at both the abstract and concrete levels. The relationship of a business process to a partner is typically peer-to-peer, requiring a two-way dependency at the service level. In other words, a partner represents both a consumer of a service provided by the business process and a provider of a service to the business process. This is especially the case when the interactions are based on one-way operations rather than on request-response operations. The notion of <partnerLinks> is used to directly model peer-to-peer conversational partner relationships. <partnerLinks> define the shape of a relationship with a partner by defining the portTypes used in the interactions in both directions. However, the actual partner service may be dynamically determined within the process. WS-BPEL uses a notion of endpoint reference, manifested as a service reference container <service-ref>, to represent the data required to describe a partner service endpoint.
Introduction of service reference container <service-ref> avoids inventing a private WS-BPEL mechanism for web service endpoint references. It also provides pluggability of different versions of service referencing or endpoint addressing schemes being used within WS-BPEL.
6.1. Partner Link Types
A <partnerLinkType> characterizes the conversational relationship between two services by defining the roles played by each of the services in the conversation and specifying the portType provided by each service to receive messages within the context of the conversation. Each <role> specifies exactly one WSDL portType. The following example illustrates the basic syntax of a <partnerLinkType> declaration:
<plnk:partnerLinkType name="BuyerSellerLink">
<plnk:role name="Buyer" portType="buy:BuyerPortType" />
<plnk:role name="Seller" portType="sell:SellerPortType" />
</plnk:partnerLinkType>
The extensibility mechanism of WSDL 1.1 is used to define <partnerLinkType> as a new definition type to be placed as an immediate child element of a <wsdl:definitions> element. This allows reuse of the WSDL target namespace specification and its import mechanism to import portType definitions. The <partnerLinkType> definition can be a separate artifact independent of either service's WSDL document. Alternatively, the <partnerLinkType> definition can be placed within the WSDL document defining the portTypes from which the different roles are defined.
The syntax for defining a <partnerLinkType> is:
<wsdl:definitions name="NCName" targetNamespace="anyURI" ...>
...
<plnk:partnerLinkType name="NCName">
<plnk:role name="NCName" portType="QName" />
<plnk:role name="NCName" portType="QName" />?
</plnk:partnerLinkType>
...
</wsdl:definitions>
This defines a <partnerLinkType> in the namespace indicated by the value of the targetNamespace attribute of the WSDL document element. The portTypes identified within <role>s are referenced by using QNames according to the rules in WSDL specifications.
Note that in some cases it can be meaningful to define a <partnerLinkType> containing exactly one <role> instead of two. That defines a partner linking scenario where one partner expresses a capability to link with any other partner, without placing any requirements on the other partner.
Examples of <partnerLinkType> declarations are found in various business process examples in this specification.
6.2. Partner Links
The services with which a business process interacts are modeled as partner links in WS-BPEL. Each <partnerLink> is characterized by a partnerLinkType. More than one <partnerLink> can be characterized by the same partnerLinkType. For example, a certain procurement process might use more than one vendor for its transactions, but might use the same partnerLinkType for all vendors.
<partnerLinks>
<partnerLink name="NCName"
partnerLinkType="QName"
myRole="NCName"?
partnerRole="NCName"?
initializePartnerRole="yes|no"? />+
</partnerLinks>
Each <partnerLink> is named, and this name is used for all service interactions via that <partnerLink>. This is critical, for example, in correlating responses to different <partnerLink>s for simultaneous requests of the same kind (see section 10.3. Invoking Web Service Operations – Invoke and 10.4. Providing Web Service Operations – Receive and Reply ).
Within a <partnerLink>, the role of the business process itself is indicated by the attribute myRole and the role of the partner is indicated by the attribute partnerRole. When a partnerLinkType has only one role, one of these attributes is omitted as appropriate. [SA00016] Note that a <partnerLink> MUST specify the myRole, or the partnerRole, or both. This syntactic constraint MUST be statically enforced
The <partnerLink> declarations specify the relationships that a WS-BPEL process will employ in its behavior. In order to utilize operations via a <partnerLink>, the binding and communication data, including endpoint references (EPR), for the <partnerLink> must be available (see also section 10.3. Invoking Web Service Operations – Invoke). The relevant information about a <partnerLink> can be set as part of business process deployment. This is outside the scope of the WS-BPEL specification. Partner link types establish a relationship between WSDL port types of two Web services. The purpose of partner link types is to keep this relationship clear within the process, and make processes with more than one partner easier to understand. No other syntactic or semantic relationships are implied by partner link types in this specification. It is also possible to bind partner links dynamically. WS-BPEL provides the mechanisms to do so via assignment of endpoint references (see section 8.4. Assignment). Since the partners are likely to be stateful, the service endpoint information may need to be extended with instance-specific information.
The initializePartnerRole attribute specifies whether the WS-BPEL processor is required to initialize a <partnerLink>'s partnerRole value. The attribute has no affect on the partnerRole's value after its initialization. [SA00017] The initializePartnerRole attribute MUST NOT be used on a partner link that does not have a partner role; this restriction MUST be statically enforced. If the initializePartnerRole attribute is set to "yes" then the WS-BPEL processor MUST initialize the EPR of the partnerRole before that EPR is first utilized by the WS-BPEL process. An example would be when an EPR is used in an <invoke> activity. If the initializePartnerRole attribute is set to "no" then the WS-BPEL processor MUST NOT initialize the EPR of the partnerRole before that EPR is first utilized by the WS-BPEL process. If the initializePartnerRole attribute is omitted then its value MUST be treated as "no".
References to a WS-BPEL processor initializing the EPR of a partnerRole relate to the infrastructure logic specific to that processor. A typical example is process deployment logic. This is in contrast to EPR initialization mechanisms outside a WS-BPEL processor, such as:
· Business logic expressed in the process definition
· Auto-assignment of EPR logic in an underlying EPR scheme, such as the reply-to feature in WS-Addressing
When initializePartnerRole is set to “yes”, the EPR value used in partnerRole initialization is typically specified as a part of WS-BPEL process deployment or execution environment configuration. Hence, the initializePartnerRole attribute may be used as a part of process deployment contract.
A <partnerLink> can be declared within a <process> or <scope> element. [SA00018] The name of a <partnerLink> MUST be unique among the names of all partner links defined within the same immediately enclosing scope. This requirement MUST be statically enforced. Access to a <partnerLink> follows common lexical scoping rules. The lifecyle of a <partnerLink> is the same as the lifecycle of the scope declaring the <partnerLink>. The initial binding information of a <partnerLink> can be set as a part of business process deployment, regardless of whether it is declared on the <process> or <scope> element level.
6.3. Endpoint References
WSDL makes an important distinction between port types and ports. Port types define abstract functionality by using abstract messages. Ports provide actual access information, including communication service endpoints and (by using extension elements) other deployment related information such as public keys for encryption. Bindings provide the glue between the two. While the user of a service must be statically dependent on the abstract interface defined by port types, some of the information contained in port definitions can typically be discovered and used dynamically.
The fundamental use of endpoint references is to serve as the mechanism for dynamic communication of port-specific data for services. An endpoint reference makes it possible in WS-BPEL to dynamically select a provider for a particular type of service and to invoke their operations. WS-BPEL provides a general mechanism for correlating messages to stateful instances of a service, and therefore endpoint references that carry instance-neutral port information are often sufficient. However, in general it is necessary to carry additional instance-identification tokens in the endpoint reference itself.
Endpoint references associated with partnerRole and myRole of <partnerLink>s are manifested as service reference containers (<service-ref>). This container is used as an envelope to wrap the actual endpoint reference value. The design pattern here is similar to those of expression language, also known as open-content models, for example:
<service-ref reference-scheme="http://example.org">
<foo:barEPR xmlns:foo="http://example.org">...</foo:barEPR>
</service-ref>
The <service-ref> has an optional attribute called reference-scheme to denote the URI of the reference interpretation scheme of service endpoint, which is the child element of <service-ref>.
The URI of reference-scheme and the namespace URI of the child element of <service-ref> will not necessarily be the same. The optional reference-scheme attribute SHOULD be used when the child element of the <service-ref> is ambiguous by itself. This optional attribute supplies further information to disambiguate the usage of the content. For example, if wsdl:service is used as the endpoint reference, different treatments of the wsdl:service element may occur.
If that attribute is not specified, the namespace URI of the content element within the wrapper MUST be used to determine the reference scheme of service endpoint.
If the attribute is specified, the URI SHOULD be used as the reference scheme of service endpoint and the content element within the wrapper is treated accordingly.
When a WS-BPEL implementation fails to interpret the combination of the reference-scheme attribute and the content element or just the content element alone, a standard fault "unsupportedReference" MUST be thrown.
The <service-ref> element is not always exposed to WS-BPEL process definitions. For example, it is not exposed in an assignment from the endpoint reference of myRole of partnerLink-A to that of partnerRole of partnerLink-B. On the contrary, it is exposed in an assignment from a messageType or element based variable through expression or from a literal <service-ref>.
7. Variable Properties
7.1. Motivation
7.1.1 Motivation for Message Properties
The data in a message consists conceptually of two parts: application data and protocol relevant data, where the protocols can be business protocols or infrastructure protocols providing higher quality of service. An example of business protocol data is the correlation tokens that are used in <correlationSets> (see section 9.2. Declaring and Using Correlation Sets). Examples of infrastructure protocols are security, transaction, and reliable messaging protocols. The business protocol data is usually found embedded in the application-visible message parts, whereas the infrastructure protocols almost always add implicit extra parts to the message types to represent protocol headers that are separate from application data. Such implicit parts are often called message context because they relate to security context, transaction context, and other similar middleware context of the interaction. Business processes might need to gain access to and manipulate both kinds of protocol-relevant data. The notion of message properties is defined as a general way of naming and representing distinguished data elements within a message, whether in application-visible data or in message context. For a full accounting of the service description aspects of infrastructure protocols, it is necessary to define notions of service policies, endpoint properties, and message context. This work is outside the scope of WS-BPEL. Message properties are defined here in a sufficiently general way to cover message context consisting of implicit parts, but the use in this specification focuses on properties embedded in application-visible data that is used in the definition of Abstract and Executable Business Processes.
7.1.2 Motivation for Variable Properties
Message properties are an instance of a more generic mechanism, <variable> properties. All variables in WS-BPEL can have properties defined on them. Properties are useful on non-message variables as a way to isolate the WS-BPEL process’s logic from the details of a particular variable’s definition. Using properties a WS-BPEL process can isolate its variable initialization logic in one place and then set and get properties on that <variable> in order to manipulate it. If the <variable>’s definition is later changed the rest of the WS-BPEL process definition that manipulates that variable can remain unchanged.
7.2. Defining Properties
A <property> definition creates a unique name for a WS-BPEL process definition and associates it with an XML Schema type. The intent is to create a name that has semantic significance beyond the type itself. For example, a sequence number can be an integer, but the integer type does not convey this significance, whereas a named sequence-number property does. Properties can refer to any parts of a variable.
A typical use for a <property> in WS-BPEL is to name a token for correlation of service instances with messages. For example, a social security number might be used to identify an individual taxpayer in a long-running multiparty business process regarding a tax matter. A social security number can appear in many different message types, but in the context of a tax-related process it has a specific significance as a taxpayer ID. Therefore a name is given to this use of the type by defining a <property>, as in the following example:
<wsdl:definitions name="properties"
targetNamespace="http://example.com/properties.wsdl"
xmlns:tns="http://example.com/properties.wsdl"
xmlns:txtyp="http://example.com/taxTypes.xsd"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
<!-- import schema taxTypes.xsd -->
<!-- define a correlation property -->
<bpel:property name="taxpayerNumber" type="txtyp:SSN" />
...
</wsdl:definitions>
In correlation, the property name must have process-wide significance to be of any use. Properties such as price, risk, response latency, and so on, which are used in conditional behavior in a business process, have similar significance. It is likely that they will be mapped to multiple messages, and therefore they need to be named as in the case of correlation properties.
Even in the general case of properties on XML typed WS-BPEL variables the property name should maintain its generic nature. The name is intended to identify a certain kind of value, often with an implied semantic. Any variable on which the property is available is therefore expected to provide a value that meets not just the syntax of the property definition but also its semantics.
The WSDL extensibility mechanism is used to define properties. The target namespace and other useful aspects of WSDL are available to them.
The syntax for a property definition is a new kind of WSDL definition as follows:
<wsdl:definitions name="NCName">
<bpel:property name="NCName" type="QName"? element="QName"? />
...
</wsdl:definitions>
[SA00019] Either the type or element attributes MUST be present but not both. Properties used in business protocols are typically embedded in application-visible message data.
7.3 Defining Property Aliases
The notion of aliasing is introduced to map a property to a field in a specific message part or variable value. The property name becomes an alias for the message part and/or location, and can be used as such in expressions and assignments. As an example, consider the following WSDL message definition:
<wsdl:definitions name="messages"
targetNamespace="http://example.com/taxMessages.wsdl"
xmlns:txtyp="http://example.com/taxTypes.xsd"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
<!-- define a WSDL application message -->
<wsdl:message name="taxpayerInfoMsg">
<wsdl:part name="identification"
element="txtyp:taxPayerInfoElem" />
</wsdl:message>
...
</wsdl:definitions>
The definition of a property and its location in a particular field of the message are shown in the next WSDL fragment:
<wsdl:definitions name="properties"
targetNamespace="http://example.com/properties.wsdl"
xmlns:tns="http://example.com/properties.wsdl"
xmlns:txtyp="http://example.com/taxTypes.xsd"
xmlns:txmsg="http://example.com/taxMessages.wsdl" ...>
<!-- define a correlation property -->
<bpel:property name="taxpayerNumber" type="txtyp:SSN" />
...
<bpel:propertyAlias propertyName="tns:taxpayerNumber"
messageType="txmsg:taxpayerInfoMsg" part="identification">
<bpel:query>txtyp:socialsecnumber</bpel:query>
</bpel:propertyAlias>
<bpel:propertyAlias propertyName="tns:taxpayerNumber"
element="txtyp:taxPayerInfoElem">
<bpel:query>txtyp:socialsecnumber</bpel:query>
</bpel:propertyAlias>
</wsdl:definitions>
The first <propertyAlias> defines a named property tns:taxpayerNumber as an alias for a location in the identification part of the message type txmsg:taxpayerInfoMsg.
The second <propertyAlias> provides a second definition for the same named property tns:taxpayerNumber but this time as an alias for a location inside of the element txtyp:taxPayerInfoElem.
The presence of both aliases means that it is possible to retrieve the social security number from both a variable holding a message of messageType txmsg:taxpayerInfo as well as an element defined using txtyp:taxPayerInfoElem.
The syntax for a <propertyAlias> definition is:
<wsdl:definitions name="NCName" ...>
<bpel:propertyAlias propertyName="QName"
messageType="QName"?
part="NCName"?
type="QName"?
element="QName"?>
<bpel:query queryLanguage="anyURI"?>?
queryString
</bpel:query>
</bpel:propertyAlias>
...
</wsdl:definitions>
The interpretation of the messageType and part attributes, as well as
the <query> element is the same as in the corresponding from-spec in copy
assignments (see section 8.4. Assignment).
[SA00020] A <propertyAlias> element MUST use one of the three following combinations of attributes:
· messageType and part,
· type or
· element.
If a <propertyAlias>
is defined with the messageType/part
combination then the property MUST be available on all WS-BPEL variables where
the messageType QName of the variable declaration is identical to that
of the <propertyAlias>. The
part attribute and <query> element are applied against
the WS-BPEL messageType
variable to either set or get the property variable in the same way that the part attribute and <query> element are used in the
first from and to specs in <copy>
assignments.
If a <propertyAlias> is
defined with a type attribute
then the property MUST be available on all WS-BPEL variables where the type
QName of the variable declaration is identical to that of the <propertyAlias>. The query is applied against the WS-BPEL variable to either set or
get the property variable in the same way that the query is used in the first
from and to specs in copy assignments when applied against WS-BPEL variables defined using a
type.
If a <propertyAlias> is defined with an element attribute then the property MUST be available on all WS-BPEL variables where the element QName of the variable declaration is identical to that of the <propertyAlias>. The query is applied against the WS-BPEL variable to either set or get the property variable in the same way that the query is used in the first from and to specs in copy assignments when applied against WS-BPEL variables defined using an element definition.
Using the same “tns:taxpayerNumber” example from above, for a message variable “myTaxPayerInfoMsg” of messageType txmsg:taxpayerInfoMsg:
<from variable="myTaxPayerInfoMsg" property="tns:taxpayerNumber" />
and
<from>$myTaxPayerInfoMsg.identification/txtyp:socialsecnumber</from>
have the same output (see section 8.4. Assignment for details).
[SA00022] A WS-BPEL process definition MUST NOT be accepted for processing if it defines two or more property aliases for the same property name and WS-BPEL variable type. For example, it is not legal to define two property aliases for the property tns:taxpayerNumber and the messageType txmsg:taxpayerInfoMsg. The same logic would prohibit having two property aliases on the same element QName and property name value or two property aliases on the same type QName and property name value.
[SA00021] Static analysis MUST detect property usages where property aliases for the associated variable's type are not found in any WSDL definitions directly imported by the WS-BPEL process. As described in 8. Data Handling and 9. Correlation, property usages in WS-BPEL include <correlationSets>, getVariableProperty functions as well as assign activity copy <from> and <to> property formats.
8. Data Handling
Business processes specify stateful interactions involving the exchange of messages between partners. The state of a business process includes the messages that are exchanged as well as intermediate data used in business logic and in composing messages sent to partners. The maintenance of the state of a business process requires the use of variables. Furthermore, the data from the state needs to be extracted and combined in interesting ways to control the behavior of the process, which requires data expressions. Finally, state update requires a notion of assignment. WS-BPEL provides these features for XML data types and WSDL message types. The XML family of standards in these areas is still evolving, and using the process-level attributes for query and expression languages allows for the incorporation of future standards.
Both Executable and Abstract Processes are permitted to use the full power of data selection and assignment. Executable Processes are not permitted to use opaque expressions, while Abstract Processes are permitted to use them to hide behavior. Detailed differences are specified in the following sections.
8.1. Variables
Variables provide the means for holding messages that constitute a part of the state of a business process. The messages held are often those that have been received from partners or are to be sent to partners. Variables can also hold data that are needed for holding state related to the process and never exchanged with partners.
WS-BPEL uses three kinds of variable declarations: WSDL message type, XML Schema type (simple or complex), and XML Schema element. The syntax of the <variables> declaration is:
<variables>
<variable name="BPELVariableName"
messageType="QName"?
type="QName"?
element="QName"?>+
from-spec?
</variable>
</variables>
An example of a <variable> declaration using a message type declared in a WSDL document with the targetNamespace "http://example.com/orders":
<variable xmlns:ORD="http://example.com/orders"
name="orderDetails"
messageType="ORD:orderDetails" />
Each <variable> is declared within a <scope> and is said to belong to that scope. Variables that belong to the global process scope are called global variables. Variables may also belong to other, non-global scopes, and such variables are called local variables. Each variable is visible only in the scope in which it is defined and in all scopes nested within the scope to which it belongs. Thus, global variables are visible throughout the process. It is possible to hide a variable declared in an outer scope by declaring a variable with an identical name in an inner scope. These rules are exactly analogous to those in programming languages with lexical scoping of variables.
[SA00023] The name of a <variable> MUST be unique among the names of all variables defined within the same immediately enclosing scope. This requirement MUST be statically enforced. [SA00024] Variable names are NCNames (as defined in XML Schema specification) but in addition they MUST NOT contain the “.” character. This restriction is necessary because the “.” character is used as a delimiter in WS-BPEL's default binding to XPath 1.0 (i.e. the binding identified by "urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0"). The delimiter separates the WS-BPEL message type variable name and the name of one of its WSDL message parts. The concatenation of the WSDL message variable name, the delimiter and the WSDL part name is used as an XPath variable reference which manifests the XML Infoset of the corresponding WSDL message part.
In this specification, the type BPELVariableName is used to describe the name of a <variable>. It is derived from the XML Schema NCName as described below. The type BPELVariableName-list is used to describe a list of variable names.
<xsd:simpleType name="BPELVariableName">
<xsd:restriction base="xsd:NCName">
<xsd:pattern value="[\i-[.]][\c-[.]]*" />
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="BPELVariableName-list">
<xsd:restriction>
<xsd:simpleType>
<xsd:list itemType="tns:BPELVariableName" />
</xsd:simpleType>
<xsd:minLength value="1" />
</xsd:restriction>
</xsd:simpleType>
Variable access follows common lexical scoping rules. A variable resolves to the nearest enclosing scope, regardless of the type of the variable, except as described in 12.6. Event Handlers. If a local variable has the same name as a variable defined in an enclosing scope, the local variable will be used in local assignments and/or the bpel:getVariableProperty function (as defined below).
[SA00025] The messageType, type or element attributes are used to specify the type of a variable. Exactly one of these attributes MUST be used. Attribute messageType refers to a WSDL message type definition. Attribute type refers to an XML Schema type (simple or complex). Attribute element refers to an XML Schema element.
Using [Infoset] terminology, the infoset for a WS-BPEL element variable consists of a Document Information Item (DII) that contains exactly one child, an Element Information Item (EII) which is referenced by the document element property. The EII is the value of the element variable.
If a WS-BPEL implementation chooses to manifest a simple type variable as an XML infoset, the infoset SHOULD consist of a DII that contains exactly one child, which is an EII referenced by the document element property. The properties of the document element, specifically the namespace name and local name properties, are undefined by this specification. An implementation MUST specify a namespace name/local name value. However the children of the document element MUST exclusively consist of a series of Character Information Items (CIIs) that represent the simple type value. A WS-BPEL implementation MAY choose to map simple type variables to non-XML-infoset data-models defined in the expression/query language being used (e.g. Boolean in XPath 1.0).
The infoset for a complex type variable consists of a DII that contains exactly one child, which is an EII referenced by the document element property. The properties of the document element, specifically the namespace name and local name properties, are undefined by this specification. An implementation MUST specify a namespace name/local name value. However the children of the document element MUST exclusively consist of the complex type values assigned to the variable.
In order to simplify data access, WSDL parts of WSDL message variables are manifested in WS-BPEL as infosets, one infoset per WSDL message part. WS-BPEL engines MUST use the following algorithm when manifesting a WSDL message part as an infoset:
for each part in the WSDL message definition,
Step 1 – Create a synthetic DII which has no children other than those specified in step 2.
Step 2a – If the WSDL message part is defined using the type attribute then create an EII as a child of the document element. The local name and namespace name of the newly created EII are determined by the WS-BPEL processor and are not specified by this document. The handling of this EII is similar to how WS-BPEL handles the containers for complex and simple type XML variables. The contents of the new EII are required to conform to the contents defined by the referenced type definition.
Step 2b – If the WSDL message part is defined using the element attribute then create an EII as a child of the document element which manifests the element defined by the referenced type definition.
The previous models are conceptual; they define how WS-BPEL submits and retrieves XML variable values using infoset definitions. WS-BPEL processors are not required to implement an infoset model. Regardless of how the variable binding is handled, the end result SHOULD duplicate the behavior defined using the infoset model above. For example, a WS-BPEL implementation may choose to bind a simple type WS-BPEL variable of type xsd:string directly to a string object in XPath 1.0. The choice of mapping MUST be consistently applied to variables and WSDL message part values of the same XML Schema type. For example, if a xsd:string variable is manifested as a string object, a xsd:string message part MUST be manifested as a string object also. For detailed definition of manifestation of WS-BPEL variables in XPath 1.0, see section 8.2.2 Binding WS-BPEL Variables In XPath 1.0.
In summary, a WS-BPEL variable is manifested as XML Infoset items in one of the following ways:
(1) a single XML infoset item: e.g. an element or complex type variable or a WSDL message part
(2) a sequence of CIIs for simple type data: e.g. used to manifest a string (these items may be manifested as a non XML infoset item when needed, e.g. Boolean)
A variable can optionally be initialized by using an in-line from-spec. From-spec is defined in section 8.4. Conceptually the in-line variable initializations are modeled as a virtual <sequence> activity that contains a series of virtual <assign> activities, one for each variable being initialized, in the order they are listed in the variable declarations. The virtual <assign> activities each contain a single virtual <copy> whose from-spec is as given in the variable initialization and the to-spec points to the variable being created.
[SA00026] Variable initialization logic contained in scopes that contain or whose children contain a start activity MUST only use idempotent functions in the from-spec. The use of idempotent functions allows for all the values for such variables to be pre-computed and re-used on each process instance.
A global variable is in an uninitialized state at the beginning of a process. A local variable is in an uninitialized state at the start of the scope it belongs to. Note that non-global scopes in general start and complete their behavior more than once in the lifetime of the process instance they belong to. Variables can be initialized by a variety of means including assignment and receipt of a message. Variables can be partially initialized with property assignment or when some but not all parts in the message type of the variable are assigned values.
An attempt during process execution to read a variable or, in the case of a message type variable, a part of a variable before it is initialized MUST result in the standard bpel:uninitializedVariable fault. This includes the <invoke> and <reply> activity, where the presence of an uninitialized part also results in the standard fault bpel:uninitializedVariable.
Variable Validation
Values stored in variables can be mutated during the course of process execution. The <validate> activity can be used to ensure that values of variables are valid against their associated XML data definition, including XML Schema simple type, complex type, element definition and XML definitions of WSDL parts. The <validate> activity has a variables attribute, listing the variables to validate. The attribute accepts one or more variable names (BPELVariableName), separated by whitespaces. The syntax of the validate activity is:
<validate variables="BPELVariableName-list" standard-attributes>
standard-elements
</validate>
When one or more variables are invalid against their correponding XML definition, a standard fault of bpel:invalidVariables fault MUST be thrown.
A WS-BPEL implementation MAY provide a mechanism to turn on/off any explicit validation, for example, the <validate> activity. A WS-BPEL implementation MAY validate incoming and outgoing messages during the execution of message related activities, e.g., <receive>, <reply>, <pick>, <onEvent> and <invoke> activities. If Schema validation is enabled and messages are invalid, "bpel:invalidVariables" fault SHOULD be thrown during those message activities.
8.2 Usage of Query and Expression Languages
This section describes the relationship between Query/Expression languages and WS-BPEL from two different perspectives. The first perspective is WS-BPEL's view of the query/expression languages. That view is restricted to what information WS-BPEL will make available for use by the Query/Expression language. The second perspective is the Query/Expression language's view of WS-BPEL, specifically how XPath 1.0's execution context is initialized by WS-BPEL.
WS-BPEL provides an extensible mechanism for the language used in queries and expressions. The languages are specified by the queryLanguage and expressionLanguage attributes of the process element. WS-BPEL constructs that require or allow queries or expressions provide the ability to override the default query/expression language for individual queries/expressions. WS-BPEL implementations MUST support the use of [XPath 1.0] as the query and expression language. XPath 1.0 is indicated by the default value of the queryLanguage and expressionLanguage attribute, which is:
urn:oasis:names:tc:wsbpel:2.0:sublang:xpath1.0
which represents the usage of XPath 1.0 within WS-BPEL 2.0.
If the execution of a query or an expression yields an unhandled language fault, the WS-BPEL standard fault bpel:subLanguageExecutionFault MUST be thrown.
8.2.1 Enclosing Elements
In order to describe the view that WS-BPEL provides to Query/Expression languages it is necessary to introduce a new term - Enclosing Element.
Definition (Enclosing Element). An Enclosing Element is defined as the parent element in the WS-BPEL process definition that contains the Query or Expression. In the following example, the <from> element is the Enclosing Element.
<process>
...
<from>$myVar/abc/def</from>
...
</process>
The in-scope namespaces of the enclosing element are the namespaces visible to the Query/Expression language. (Note: XPath 1.0 does not have default namespace concept.)
The links, variables, partnerLinks, etc. that are visible to a Query/Expression language are defined based on the entities’ visibility to the activity that the Enclosing Element is contained within. Query/Expression languages need not manifest all the different objects. Only the objects in scope to the Enclosing Element’s enclosing activity SHOULD be visible from within the Query/Expression language.
Evaluation of a WS-BPEL expression or query will yield one of the following (here we use XPath 1.0 expressions as examples):
· a single XML infoset item: e.g. $myFooVar/lines/line[2]
· a collection of XML infoset items e.g. $myFooVar/lines/*
·
a sequence of CIIs for simple type data
e.g. $myFooVar/lines/line[2]/text()
(Please note this sequence of items may be manifested as a non XML infoset item
when needed. e.g. as a Boolean)
· a variable reference: e.g. <from>$myFooVar</from>
8.2.2 Binding WS-BPEL Variables In XPath 1.0
With the exception of link expressions whose variable access syntax and semantics are described in section 8.2.4 Default use of XPath 1.0 for Expression and Query Languages, WS-BPEL variables are accessible in XPath expressions via XPath variable bindings. Specifically, all WS-BPEL variables visible from the Enclosing Element of an XPath expression MUST be made available to the XPath processor by manifesting the WS-BPEL variable as an XPath variable binding whose name is the same as the WS-BPEL variable's name, except in the case of variables declared with a WSDL messageType, which requires some special handling (discussed below).
WS-BPEL variables declared using an element MUST be manifested as a node-set XPath variable with a single member node. That node is a synthetic DII that contains a single child, the document element, which is the value of the WS-BPEL variable. The XPath variable binding will bind to the document element. For example, given the following Schema definition:
<xsd:element name="StatusContainer">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="statusDescription" type="xsd:string"
form="qualified" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
And given the following variable declaration:
<variable name="AStatus" element="e:StatusContainer" />
Then a WS-BPEL XPath expression to access the value of the statusDescription element, assuming the AStatus variable is in scope, would look like:
$AStatus/e:statusDescription
$AStatus points at the variable's document element, StatusContainer. So to access StatusContainer's child statusDescription it is only necessary to specify the child's element name.
WS-BPEL variables declared using a complex type MUST be manifested as a node-set XPath variable with one member node containing the anonymous document element that contains the actual value of the WS-BPEL complex type variable. The XPath variable binds to the document element. For example, given the following Schema definition:
<xsd:complexType name="AuctionResults">
<xsd:sequence>
<xsd:element name="AuctionResult" maxOccurs="unbounded"
form="qualified">
<xsd:complexType>
<xsd:attribute name="AuctionID" type="xsd:int" />
<xsd:attribute name="Result" type="xsd:string" />
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
And given the following variable declaration:
<variable name="Results" type="e:AuctionResults" />
Then a WS-BPEL XPath expression to access the value of the second AuctionID attribute would look like:
$Results/e:AuctionResult[2]/@AuctionID
$Results points at the variable’s document element, AuctionResult[2] points to the second AuctionResult child of the document element, and @AuctionID points to the AuctionID attribute on the selected AuctionResult element.
WS-BPEL messageType variables MUST be manifested in XPath as a series of variables, one variable per part in the messageType. Each variable is named by concatenating the message variable's name, the "." character and the name of the part. The data in a WS-BPEL messageType variable is not made available as one single XPath variable to general XPath processing under the default query and expression language binding. For example, if a messageType variable was named "myMessageTypeVar" and it contained two parts, "msgPart1" and "msgPart2" then the XPath binding that had "myMessageTypeVar" in scope would manifest two XPath variables, $myMessageTypeVar.msgPart1 and $myMessageTypeVar.msgPart2.
WSDL message parts are always defined using either an XSD element, an XSD complex type or a XSD simple type. As such the manifestation of these message parts in XPath can be handled in the same manner as specified herein for element, complex type and simple type WS-BPEL variables.
Below is a full example of how a WSDL message type is manifested in WS-BPEL XPath.
<message name="StatusMessage">
<part name="StatusPart1" element="e:StatusContainer" />
<part name="StatusPart2" element="e:StatusContainer" />
</message>
And given the following variable declaration:
<variable name="StatusVariable" messageType="e:StatusMessage" />
Then a WS-BPEL XPath expression to access the second part’s statusDescription element would look like:
$StatusVariable.StatusPart2/e:statusDescription
It is possible to write XPath queries that can simultaneously query across multiple parts of a WSDL message variable by applying a union operator to create one single nodeset. For example:
( $StatusVariable.StatusPart1
| $StatusVariable.StatusPart2 )//e:statusDescription
WS-BPEL simple type variables MUST be manifested directly as either an XPath string, Boolean or float object. If the XML Schema type of the WS-BPEL simple type variable is xsd:boolean or any types that are restrictions of xsd:boolean then the WS-BPEL variable MUST be manifested as an XPath Boolean object. If the XML Schema type of the WS-BPEL simple type variable is xsd:float, xsd:int, xsd:unsignedInt or any restrictions of those types then the WS-BPEL variable MUST be manifested as an XPath float object. Any other XML Schema types MUST be manifested as an XPath string object.
The precision of the float object in XPath 1.0 is not sufficient to capture the full value of some XML Schema data types, such as xsd:decimal. XSD numeric values that cannot be expressed without loss of accuracy as XPath float objects MUST be translated into XPath string objects