Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language

1.4.1 RFC 2119 Keywords

The keywords “MUST”, “MUST NOT”, “EQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119 [IETF RFC 2119].

1.4.2 RFC 3986 Namespaces

Namespace names of the general form:

• "http://example.org/..." and

• "http://example.com/..."

represent application or context-dependent URIs [IETF RFC 3986].

1.4.3 Prefixes and Namespaces Used in This Specification

This specification uses predefined namespace prefixes throughout; they are given in the following list. Note that the choice of any namespace prefix is arbitrary and not semantically significant (see [XML Namespaces]).

wsdl

"http://www.w3.org/2005/05/wsdl"

Defined by this specification.

wsdli

"http://www.w3.org/2005/05/wsdl-instance"

Defined by this specification 7.1 wsdli:wsdlLocation attribute information item.

wrpc

"http://www.w3.org/2005/05/wsdl/rpc"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

wsoap

"http://www.w3.org/2005/05/wsdl/soap"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

whttp

"http://www.w3.org/2005/05/wsdl/http"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

xs

"http://www.w3.org/2001/XMLSchema"

Defined in the W3C XML Schema specification [XML Schema: Structures], [XML Schema: Datatypes].

xsi

"http://www.w3.org/2001/XMLSchema-instance"

Defined in the W3C XML Schema specification [XML Schema: Structures], [XML Schema: Datatypes].

1.4.4 Terms Used in This Specification

This section describes the terms and concepts introduced in Part 1 of the WSDL Version 2.0 specification (this document).

Actual Value

As in [XML Schema: Structures], the phrase actual value is used to refer to the member of the value space of the simple type definition associated with an attribute information item which corresponds to its normalized value. This will often be a string, but may also be an integer, a boolean, a URI reference, etc.

Inlined Schema

An XML schema that is defined in a the xs:types element information item of a WSDL 2.0 description. For example, an XML 1.0 Schema defined in an xs:schema element information item 3.1.2 Inlining XML Schema.

1.4.5 XML Information Set Properties

This specification refers to properties in the XML Information Set [XML Information Set]. Such properties are denoted by square brackets, e.g. [children], [attributes].

1.4.6 WSDL 2.0 Component Model Properties

This specification defines and refers to properties in the WSDL 2.0 Component Model 2. Component Model. Such properties are denoted by curly brackets, e.g. {name}, {interfaces}.

This specification uses a consistent naming convention for component model properties that refer to components. If a property refers to a required or optional component, then the property name is the same as the component name. If a property refers to a set of components, then the property name is the pluralized form of the component name.

1.4.7 Z Notation

Z Notation [Z Notation Reference Manual] was used in the development of this specification. Z Notation is a formal specification language that is based on standard mathematical notation. The Z Notation for this specification has been verified using the Fuzz 2000 type-checker [Fuzz 2000].

Since Z Notation is not widely known, it is not included the normative version of this specification. However, it is included in a non-normative version which allows to dynamically hide and show the Z Notation. Browsers correctly display the mathematical Unicode characters, provided that the required fonts are installed. Mathematical fonts for Mozilla Firefox can be downloaded from the Mozilla Web site.

The Z Notation was used to improve the quality of the normative text that defines the Component Model, and to help ensure that the test suite covered all important rules implied by the Component Model. However, the Z Notation is non-normative, so any conflict between it and the normative text is an error in the Z Notation. Readers and implementors may nevertheless find the Z Notation useful in cases where the normative text is unclear.

There are two elements of Z Notation syntax that conflict with the notational conventions described in the preceeding sections. In Z Notation, square brackets are used to introduce basic sets, e.g. [ID], which conflicts with the use of square brackets to denote XML Information Set properties 1.4.5 XML Information Set Properties. Also, in Z Notation, curly brackets are used to denote set display and set comprehension, e.g. {1, 2, 3}, which conflicts with the use of curly brackets to denote WSDL 2.0 Component Model properties 1.4.6 WSDL 2.0 Component Model Properties. However, the intended meaning of square and curly brackets should be clear from their context and this minor notational conflict should not cause any confusion.

1.4.8 BNF Pseudo-Schemas

Pseudo-schemas are provided for each component, before the description of the component. They use BNF-style conventions for attributes and elements: "?" denotes optionality (i.e. zero or one occurrences), "*" denotes zero or more occurrences, "+" one or more occurrences, "[" and "]" are used to form groups, and "|" represents choice. Attributes are conventionally assigned a value which corresponds to their type, as defined in the normative schema.

<!-- sample pseudo-schema -->
<defined_element
      required_attribute_of_type_string="xs:string"
      optional_attribute_of_type_int="xs:int"? >
  <required_element />
  <optional_element />?
  <one_or_more_of_these_elements />+
  [ <choice_1 /> | <choice_2 /> ]*
</defined_element>

2.1.1 The Description Component

At the abstract level, the Description component is just a container for two categories of components: WSDL 2.0 components and type system components.

WSDL 2.0 components are interfaces, bindings and services. Type system components are element declarations and type definitions.

Interface, Binding, Service, Element Declaration, and Type Definition components are directly contained in the Description component and are referred to as top-level components. The top-level WSDL 2.0 components contain other components, e.g. Interface Operation and Endpoint, which are referred to as nested components. Nested components may contain other nested components. The component that contains a nested component is referred to as the parent of the nested components. Nested components have a {parent} property that is a reference to their parent component.

Parent...

Parent  [ show all ]  [ hide all ]

Let Parent represent the {parent} property of a nested component:

Parent
parent : ID

See ID.

ParentRI...

ParentRI  [ show all ]  [ hide all ]

The parent of a nested component in the component model MUST also be in the component model.

Let ParentRI represent this {parent} property referential integrity constraint:

ParentRI
ComponentModel1
Parent
parent∈componentIds

See ComponentModel2, Parent.

Type system components describe the constraints on a message's content. By default, these constraints are expressed in terms of the [XML Information Set], i.e. they define the [local name], [namespace name], [children] and [attributes] properties of an element information item. Type systems based upon other data models are generally accommodated by extensions to WSDL 2.0; see 6. Language Extensibility. In the case where they define information equivalent to that of a XML Schema global element declaration, they can be treated as if they were such a declaration.

This specification does not define the behavior of a WSDL 2.0 document that uses multiple schema languages for describing type system components simultaneously.

ElementContentModel...

ElementContentModel  [ show all ]  [ hide all ]

Let ElementContentModel be the set of all models that define the allowable values for the [children] and [attribute] properties of an element information item:

[ElementContentModel]

The detailed structure of ElementContentModel is immaterial for the purposes of this specification. It is can be safely thought of as some superset of the set of all XML Schema complex type definitions.

ElementDeclaration...

ElementDeclaration  [ show all ]  [ hide all ]

Let ElementDeclaration be the type of Element Declaration components:

• Let name be the QName defined by the [local name] and [namespace name] properties of the element information item.

• Let elementContentModel be the element content model that constrains the allowable contents of the [children] and [attribute] properties of the element information item.

ElementDeclaration
Identifier
name : QName
elementContentModel : ElementContentModel

See QName, ElementContentModel.

TypeDefinition...

TypeDefinition  [ show all ]  [ hide all ]

Let TypeDefinition be the type of the Type Definition component:

• Let name be the QName of the type definition.

• Let elementContentModel be the element content model that constrains the allowable contents of the [children] and [attribute] properties of the element information item described by the type definition.

TypeDefinition
Identifier
name : QName
elementContentModel : ElementContentModel

See QName, ElementContentModel.

The properties of the Description component are as follows:

• {interfaces} OPTIONAL. A set of Interface components.

• {bindings} OPTIONAL. A set of Binding components.

• {services} OPTIONAL. A set of Service components.

• {element declarations} OPTIONAL. A set of named element declarations, each one isomorphic to a global element declaration as defined by XML Schema.

• {type definitions} OPTIONAL. A set of named type definitions, each one isomorphic to a global type definition as defined by XML Schema.

Description...

Description  [ show all ]  [ hide all ]

Let Description be the set of all Description components:

Description
Identifier
interfaces :ℙID
bindings :ℙID
services :ℙID
elementDeclarations :ℙID
typeDefinitions :ℙID

See ID.

DescriptionRI...

DescriptionRI  [ show all ]  [ hide all ]

The component model contains a unique Description component. Each component refered to by the properties of the Description component must exist in the component model.

Let DescriptionRI express these referential integrity constraints on the Description component:

• Let descriptionComp be the unique Description component.

DescriptionRI
ComponentModel2
descriptionComp : Description
descriptionComps = {descriptionComp}
descriptionComp.interfaces = interfaceIds
descriptionComp.bindings = bindingIds
descriptionComp.services = serviceIds
descriptionComp.elementDeclarations = elementDeclIds
descriptionComp.typeDefinitions = typeDefIds

See ComponentModel2, Description.

• The component model contains a unique Description component.

• The Description component contains exactly the set of Interface components contained in the component model.

• The Description component contains exactly the set of Binding components contained in the component model.

• The Description component contains exactly the set of Service components contained in the component model.

• The Description component contains exactly the set of Element Declaration components contained in the component model.

• The Description component contains exactly the set of Type Definition components contained in the component model.

The set of top-level components contained in the Description component associated with an initial WSDL 2.0 document consists of the components defined in the initial document and the components associated with the documents that the initial document includes or imports. The component model makes no distinction between the components that are defined in the initial document versus those that are defined in the included or imported documents. However, any WSDL 2.0 document that contains component definitions that refer by QName to WSDL 2.0 components that belong to a different namespace MUST contain a ws:import element information item for that namespace (see 4.2 Importing Descriptions). Furthermore, all QName references, whether to the same or to different namespaces MUST resolve to components (see 2.19 QName resolution).

DescriptionKeys...

DescriptionKeys  [ show all ]  [ hide all ]

Let DescriptionKeys express the QName uniqueness constraint on the Description component:

DescriptionKeys
ComponentModel2
∀x, y : elementDeclComps •
x.name = y.name⇒x = y
∀x, y : typeDefComps •
x.name = y.name⇒x = y
∀x, y : interfaceComps •
x.name = y.name⇒x = y
∀x, y : bindingComps •
x.name = y.name⇒x = y
∀x, y : serviceComps •
x.name = y.name⇒x = y

See ComponentModel2.

• No two Element Declaration components have the same QName.

• No two Type Definition components have the same QName.

• No two Interface components have the same QName.

• No two Binding components have the same QName.

• No two Service components have the same QName.

In addition to WSDL 2.0 components and type system components, additional extension components MAY be added via extensibility 6. Language Extensibility. Further, additional properties to WSDL 2.0 and type system components MAY also be added via extensibility.

2.1.2 XML Representation of Description Component

<description
      targetNamespace="xs:anyURI" >
  <documentation />?
  [ <import /> | <include /> ]*
  <types />?
  [ <interface /> | <binding /> | <service /> ]*
</description>

WSDL 2.0 definitions are represented in XML by one or more WSDL 2.0 Information Sets (Infosets), that is one or more description element information items. A WSDL 2.0 Infoset contains representations for a collection of WSDL 2.0 components which share a common target namespace. A WSDL 2.0 Infoset which contains one or more import element information items 4.2 Importing Descriptions corresponds to a collection with components drawn from multiple target namespaces.

The components directly defined or included within a Description component are said to belong to the same target namespace. The target namespace therefore groups a set of related component definitions and represents an unambiguous name for the intended semantics of the collection of components. The value of the targetNamespace attribute information item SHOULD be a dereferenceable URI. It SHOULD resolve to a human or machine processable document that directly or indirectly defines the intended semantics of those components. It MAY resolve to a WSDL 2.0 document which provides service description information for that namespace.

If a service description is split into multiple documents (which may be combined as needed via 4.1 Including Descriptions), then the targetNamespace attribute information item SHOULD resolve to a master document which includes all the WSDL 2.0 documents needed for that service description. This approach enables the WSDL 2.0 component designators' fragment identifiers to be properly resolvable.

Imported components have different target namespace values from the Description component that is importing them. Thus importing is the mechanism to use components from one namespace in another set of definitions.

Each WSDL 2.0 or type system component MUST be uniquely identified by its qualified name. That is, if two distinct components of the same kind (Interface, Binding etc.) are in the same target namespace, then their QNames MUST be unique. However, different kinds of components (e.g., an Interface component and a Binding component) MAY have the same QName. Thus, QNames of components must be unique within the space of those components in a given target namespace.

The description element information item has the following Infoset properties:

• A [local name] of description .

• A [namespace name] of "http://www.w3.org/2005/05/wsdl".

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED targetNamespace attribute information item as described below in 2.1.2.1 targetNamespace attribute information item.

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information items amongst its [children], in order as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more include element information items (see 4.1 Including Descriptions)

     • Zero or more import element information items (see 4.2 Importing Descriptions)

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

  3. An OPTIONAL types element information item (see 3. Types).

  4. Zero or more element information items from among the following, in any order:

     • interface element information items (see 2.2.2 XML Representation of Interface Component).

     • binding element information items (see 2.9.2 XML Representation of Binding Component).

     • service element information items (see 2.14.2 XML Representation of Service Component).

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.1.3 Mapping Description's XML Representation to Component Properties

The mapping from the XML Representation of the description element information item (see 2.1.2 XML Representation of Description Component) to the properties of the Description component (see 2.1.1 The Description Component) is described in Table 2-1.

2.2.1 The Interface Component

An Interface component describes sequences of messages that a service sends and/or receives. It does this by grouping related messages into operations. An operation is a sequence of input and output messages, and an interface is a set of operations.

An interface can optionally extend one or more other interfaces. To avoid circular definitions, an interface MUST NOT appear as an element of the set of interfaces it extends, either directly or indirectly. The set of operations available in an interface includes all the operations defined by the interfaces it extends, along with any operations it directly defines. The operations directly defined on an interface are referred to as the declared operations of the interface. In the process, operation components that are equivalent per 2.17 Equivalence of Components are treated as one. The interface extension mechanism behaves in a similar way for all other components that can be defined inside an interface, namely Interface Fault, Feature and Property components.

Interfaces are named constructs and can be referred to by QName (see 2.19 QName resolution). For instance, Binding components refer to interfaces in this way.

The properties of the Interface component are as follows:

• {name} REQUIRED. An xs:QName.

• {extended interfaces} OPTIONAL. A set of declared Interface components which this interface extends.

• {interface faults} OPTIONAL. The set of declared Interface Fault components. The namespace name of the {name} property of each Interface Fault in this set MUST be the same as the namespace name of the {name} property of this Interface component.

• {interface operations} OPTIONAL. A set of declared Interface Operation components. The namespace name of the {name} property of each Interface Operation in this set MUST be the same as the namespace name of the {name} property of this Interface component.

• {features} OPTIONAL. A set of declared Feature components.

• {properties} OPTIONAL. A set of declared Property components.

Interface...

Interface  [ show all ]  [ hide all ]

Let Interface be the set of all Interface components:

• Let allExtendedInterfaces be the set off all interfaces that are extended directly or indirectly by this interface.

• Let allInterfaceFaults be the set of all faults that are directly or indirectly on this interface.

• Let allInterfaceOperations be the set of all operations that are directly or indirectly on this interface.

Interface
Base
name : QName
extendedInterfaces :ℙID
interfaceFaults :ℙID
interfaceOperations :ℙID
allExtendedInterfaces :ℙID
allInterfaceFaults :ℙID
allInterfaceOperations :ℙID
extendedInterfaces⊆allExtendedInterfaces
interfaceFaults⊆allInterfaceFaults
interfaceOperations⊆allInterfaceOperations

See Base, QName, ID.

InterfaceRI...

InterfaceRI  [ show all ]  [ hide all ]

Each component referenced by an Interface component must exist in the component model.

Let InterfaceRI express the referential integrity constraints on the Interface component:

InterfaceRI
ComponentModel2
∀Interface |θInterface∈interfaceComps •
BaseRI∧
extendedInterfaces⊂interfaceIds∧
interfaceFaults⊆interfaceFaultIds∧
interfaceOperations⊆interfaceOpIds

See ComponentModel2, Interface, BaseRI.

This Z schema introduces some additional notation. The universal quantifier ∀Interface declares each field that is part of the Interface schema as an in-scope variable and constrains them to satify the rules for Interface. The expression θInterface assembles these variables into Interface record or struct. The expression θInterface∈interfaceComps constrains the Interface record to exist in the component model.

• Every Interface component satifies the base referential integrity constraints.

• The Interface components extended by each Interface component are contained in the component model.

• The Interface Fault components of each Interface component are contained in the component model.

• The Interface Operation components of each Interface component are contained in the component model.

InterfaceParent...

InterfaceParent  [ show all ]  [ hide all ]

An Interface component contains nested Interface Operation, Interface Fault, Feature, and Property components. These components MUST have the Interface component as their parent.

Let InterfaceParent express the constraints on the {parent} properties of the nested components of an Interface component:

InterfaceParent
ComponentModel2
∀c : interfaceComps;
if : interfaceFaultComps; io : interfaceOpComps;
f : featureComps; p : propertyComps •
if.id∈c.interfaceFaults⇒if.parent = c.id∧
io.id∈c.interfaceOperations⇒io.parent = c.id∧
f.id∈c.features⇒f.parent = c.id∧
p.id∈c.properties⇒p.parent = c.id

See ComponentModel2.

• Each Interface component is the parent of any Interface Fault component it contains.

• Each Interface component is the parent of any Interface Operation component it contains.

• Each Interface component is the parent of any Feature component it contains.

• Each Interface component is the parent of any Property component it contains.

InterfaceClosure...

InterfaceClosure  [ show all ]  [ hide all ]

The set of all extended interfaces, faults, and operations that are available on an Interface component consist of those that are declared on the component and those that are available on its extendend interfaces. This rule can also be expressed by saying that faults and operations that are available on an interface include those that are available in the transitive closure of the extends relation on the interface.

Let InterfaceClosure express the Interface transitive closure constraints:

• Let extends be the extension relation on Interface components.

InterfaceClosure
ComponentModel2
extends : Interface↔Interface
extends = { x, y : interfaceComps |
y.id∈x.extendedInterfaces }
∀x : interfaceComps •
x↦x∉extends∧
x.allExtendedInterfaces =
{ y : interfaceComps | x↦y∈extends+• y.id }∧
x.allInterfaceFaults =
{ y : interfaceComps; f : interfaceFaultIds |
x↦y∈extends*∧
f∈y.interfaceFaults • f }
∧
x.allInterfaceOperations =
{ y : interfaceComps; o : interfaceOpIds |
x↦y∈extends*∧
o∈y.interfaceOperations • o }

See ComponentModel2, Interface.

• The extends relation relation each interface to the interfaces it directly extends.

• The set of all interfaces directly or indirectly extended by an interface is the transitive closure of the extends relation.

• The set of all faults available in an interface is the all of all faults defined on the interface and the interfaces it directly or indirectly extends.

• The set of all operations available in an interface is the all of all operations defined on the interface and the interfaces it directly or indirectly extends.

For each Interface component in the {interfaces} property of a description container, the {name} property MUST be unique.

InterfaceKeys...

InterfaceKeys  [ show all ]  [ hide all ]

Each component that is contained in an Interface component has a key that uniquely identifies it.

Let InterfaceKeys express the key constraints on Interface components:

InterfaceKeys
ComponentModel2
∀c : interfaceComps; x, y : interfaceFaultComps |
x.id∈c.interfaceFaults∧y.id∈c.interfaceFaults •
x.name = y.name⇒x = y
∀c : interfaceComps; x, y : interfaceOpComps |
x.id∈c.interfaceOperations∧y.id∈c.interfaceOperations •
x.name = y.name⇒x = y
∀c : interfaceComps; x, y : featureComps |
x.id∈c.features∧y.id∈c.features •
x.uri = y.uri⇒x = y
∀c : interfaceComps; x, y : propertyComps |
x.id∈c.properties∧y.id∈c.properties •
x.uri = y.uri⇒x = y

See ComponentModel2.

• No two Interface Fault components within an Interface component have the same QName.

• No two Interface Operations components within an Interface component have the same QName.

• No two Feature components within an Interface component have the same URI.

• No two Property components within an Interface component have the same URI.

2.2.2 XML Representation of Interface Component

<description>
  <interface
        name="xs:NCName" 
        extends="list of xs:QName"?
        styleDefault="list of xs:anyURI"? >
    <documentation />?
    [ <fault /> | <operation /> | <feature /> | <property /> ]*
  </interface>
</description>

The XML representation for an Interface component is an element information item with the following Infoset properties:

• A [local name] of interface

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED name attribute information item as described below in 2.2.2.1 name attribute information item with interface [owner element].

  • An OPTIONAL extends attribute information item as described below in 2.2.2.2 extends attribute information item.

  • An OPTIONAL styleDefault attribute information item as described below in 2.2.2.3 styleDefault attribute information item.

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information items amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more fault element information items 2.3.2 XML Representation of Interface Fault Component.

     • Zero or more operation element information items 2.4.2 XML Representation of Interface Operation Component.

     • Zero or more feature element information items 2.7.2 XML Representation of Feature Component.

     • Zero or more property element information items 2.8.2 XML Representation of Property Component.

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.2.3 Mapping Interface's XML Representation to Component Properties

The mapping from the XML Representation of the interface element information item (see 2.2.2 XML Representation of Interface Component) to the properties of the Interface component (see 2.2.1 The Interface Component) is as described in Table 2-2.

Note that, per 2.2.1 The Interface Component, the Interface components in the {extended interfaces} property of a given Interface component MUST NOT contain that Interface component in any of their {extended interfaces} properties, that is to say, recursive extension of interfaces is disallowed.

2.3.1 The Interface Fault Component

A fault is an event that occurs during the execution of a message exchange that disrupts the normal flow of messages.

A fault is typically raised when a party is unable to communicate an error condition inside the normal message flow, or a party wishes to terminate a message exchange. A fault message may be used to communicate out of band information such as the reason for the error, the origin of the fault, as well as other informal diagnostics such as a program stack trace.

An Interface Fault component describes a fault that MAY occur during invocation of an operation of the interface. The Interface Fault component declares an abstract fault by naming it and indicating the contents of the fault message. When and how the fault message flows is indicated by the Interface Operation component 2.4 Interface Operation.

The Interface Fault component provides a clear mechanism to name and describe the set of faults an interface may generate. This allows operations to easily identify the individual faults they may generate by name. This mechanism allows the ready identification of the same fault occurring across multiple operations and referenced in multiple bindings as well as reducing duplication of description for an individual fault.

Note that faults other than the ones described in the Interface component can also be generated at run-time, i.e. faults are an open set.

The properties of the Interface Fault component are as follows:

• {name} REQUIRED. An xs:QName.

• {element declaration} OPTIONAL. A reference to an XML element declaration in the {element declarations} property of 2.1.1 The Description Component. This element represents the content or “payload” of the fault.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Interface component that contains this component in its {interface faults} property.

InterfaceFault...

InterfaceFault  [ show all ]  [ hide all ]

Let InterfaceFault be the set of all Interface Fault components:

InterfaceFault
NestedBase
name : QName
elementDeclaration : OPTIONAL[ID]

See NestedBase, QName, OPTIONAL, ID.

InterfaceFaultRI...

InterfaceFaultRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Fault component must exist in the component model.

Let InterfaceFaultRI express the referential integrity constraints on the Interface Fault component:

InterfaceFaultRI
ComponentModel2
∀InterfaceFault |θInterfaceFault∈interfaceFaultComps •
NestedBaseRI∧
elementDeclaration⊆elementDeclIds

See ComponentModel2, InterfaceFault, NestedBaseRI.

• Every Interface Fault component satifies the base referential integrity constraints.

• The Element Declaration components of each Interface Fault component are contained in the component model.

If a type system NOT based on the XML Infoset [XML Information Set] is in use (as considered in 3.2 Using Other Schema Languages) then additional properties would need to be added to the Interface Fault Component (along with extensibility attributes to its XML representation) to allow associating such message types with the message reference.

For each Interface Fault component in the {interface faults} property of an Interface component, the {name} property must be unique.

Interface Fault components are uniquely identified by the the QName of the enclosing Interface component and QName of the Interface Fault component itself.

In cases where, due to an interface extending one or more other interfaces, two or more Interface Faults components have the same value for their {name} property, then the component models of those Interface Fault components MUST be equivalent (see 2.17 Equivalence of Components). If the Interface Fault components are equivalent then they are considered to collapse into a single component. It is an error if two Interface Fault components have the same value for their {name} properties but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for the namespace name of their {name} property also have one or more faults that have the same value for their {name} property then those two interfaces cannot both form part of the derivation chain of a derived interface unless those faults are the same fault.

2.3.2 XML Representation of Interface Fault Component

<description>
  <interface>
    <fault
          name="xs:NCName" 
          element="xs:QName"? >
      <documentation />?
      [ <feature /> | <property /> ]*
    </fault>
  </interface>
</description>

The XML representation for an Interface Fault component is an element information item with the following Infoset properties:

• A [local name] of fault

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED name attribute information item as described below in 2.3.2.1 name attribute information item with fault [owner element].

  • An OPTIONAL element attribute information item as described below in 2.3.2.2 element attribute information item with fault [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information item amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more feature element information items 2.7.2 XML Representation of Feature Component

     • Zero or more property element information items 2.8.2 XML Representation of Property Component

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.3.3 Mapping Interface Fault's XML Representation to Component Properties

The mapping from the XML Representation of the fault element information item (see 2.3.2 XML Representation of Interface Fault Component) to the properties of the Interface Fault component (see 2.3.1 The Interface Fault Component) is as described in Table 2-3.

2.4.1 The Interface Operation Component

An Interface Operation component describes an operation that a given interface supports. An operation is an interaction with the service consisting of a set of (ordinary and fault) messages exchanged between the service and the other parties involved in the interaction. The sequencing and cardinality of the messages involved in a particular interaction is governed by the message exchange pattern used by the operation (see {message exchange pattern} property).

A message exchange pattern defines placeholders for messages, the participants in the pattern (i.e., the sources and sinks of the messages), and the cardinality and sequencing of messages exchanged by the participants. The message placeholders are associated with specific message types by the operation that uses the pattern by means of message and fault references (see {inteface message references} and {interface fault references} properties). The service whose operation is using the pattern becomes one of the participants of the pattern. This specification does not define a machine understandable language for defining message exchange patterns, nor does it define any specific patterns. The companion specification, [WSDL 2.0 Adjuncts] defines a set of such patterns and defines identifying URIs any of which MAY be used as the value of the {message exchange pattern} property.

The properties of the Interface Operation component are as follows:

• {name} REQUIRED. An xs:QName.

• {message exchange pattern} REQUIRED. An xs:anyURI identifying the message exchange pattern used by the operation. This URI MUST be an absolute URI (see [IETF RFC 3986]).

• {interface message references} OPTIONAL. A set of Interface Message Reference components for the ordinary messages the operation accepts or sends. (See 2.5 Interface Message Reference.)

• {interface fault references} OPTIONAL. A set of Interface Fault Reference components for the fault messages the operation accepts or sends. (See 2.6 Interface Fault Reference.)

• {style} OPTIONAL. A set of xs:anyURIs identifying the rules that were used to construct the {element} properties of {interface message references}. (See 2.4.1.1 Operation Style.) These URIs MUST be absolute URIs (see [IETF RFC 3986]).

• {safety} REQUIRED. An xs:boolean indicating whether the operation is asserted to be safe (as defined in Section 3.5 of [Web Architecture]) for users of the described service to invoke. If this property is false, then no assertion has been made about the safety of the operation, thus the operation MAY or MAY NOT be safe. However, an operation SHOULD be marked safe if it meets the criteria for a safe interaction defined in Section 3.5 of [Web Architecture].

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Interface component that contains this component in its {interface operations} property.

InterfaceOperation...

InterfaceOperation  [ show all ]  [ hide all ]

Let InterfaceOperation be the set of all Interface Operation components:

InterfaceOperation
NestedBase
name : QName
messageExchangePattern : AbsoluteURI
interfaceMessageReferences :ℙID
interfaceFaultReferences :ℙID
style :ℙAbsoluteURI
safety : Boolean

See NestedBase, QName, AbsoluteURI, ID, Boolean.

InterfaceOperationRI...

InterfaceOperationRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Operation component must exist in the component model.

Let InterfaceOperationRI express the referential integrity constraints on the Interface Operation component:

InterfaceOperationRI
ComponentModel2
∀InterfaceOperation |θInterfaceOperation∈interfaceOpComps •
NestedBaseRI∧
interfaceMessageReferences⊆interfaceMessageRefIds∧
interfaceFaultReferences⊆interfaceFaultRefIds

See ComponentModel2, InterfaceOperation, NestedBaseRI.

• Every Interface Operation component satifies the base referential integrity constraints.

• The Interface Message Reference components of each Interface Operation component are contained in the component model.

• The Interface Fault Reference components of each Interface Operation component are contained in the component model.

For each Interface Operation component in the {interface operations} property of an Interface component, the {name} property MUST be unique.

Interface Operation components are uniquely identified by the the QName of the enclosing Interface component and QName of the Interface Operation component itself.

In cases where, due to an interface extending one or more other interfaces, two or more Interface Operation components have the same value for their {name} property, then the component models of those Interface Operation components MUST be equivalent (see 2.17 Equivalence of Components). If the Interface Operation components are equivalent then they are considered to collapse into a single component. It is an error if two Interface Operation components have the same value for their {name} property but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for the namespace name of their {name} property also have one or more operations that have the same value for their {name} property then those two interfaces cannot both form part of the derivation chain of a derived interface unless those operations are the same operation.

More than one Interface Fault Reference component in the {interface fault references} property of an Interface Operation component may refer to the same message label. In that case, the listed fault types define alternative fault messages. This allows one to indicate that there is more than one type of fault that is related to that message.

2.4.2 XML Representation of Interface Operation Component

<description>
  <interface>
    <operation
          name="xs:NCName" 
          pattern="xs:anyURI"
          style="list of xs:anyURI"? 
          safe="xs:boolean"? >
      <documentation />?
      [ <feature /> | <property /> | 
        [ <input /> | <output /> | <infault /> | <outfault /> ]+
      ]*
    </operation>
  </interface>
</description>

The XML representation for an Interface Operation component is an element information item with the following Infoset properties:

• A [local name] of operation

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• Two or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED name attribute information item as described below in 2.4.2.1 name attribute information item with operation [owner element].

  • A REQUIRED pattern attribute information item as described below in 2.4.2.2 pattern attribute information item with operation [owner element].

  • An OPTIONAL style attribute information item as described below in 2.4.2.3 style attribute information item with operation [owner element].

  • An OPTIONAL safe attribute information item as described below in 2.4.2.4 safe attribute information item with operation [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• One or more element information item amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. One or more element information items from among the following, in any order:

     • One or more element information items from among the following, in any order:

       • Zero or more input element information items (see 2.5.2 XML Representation of Interface Message Reference Component).

       • Zero or more output element information items (see 2.5.2 XML Representation of Interface Message Reference Component).

       • Zero or more infault element information items (see 2.6.2 XML Representation of Interface Fault Reference).

       • Zero or more outfault element information items (see 2.6.2 XML Representation of Interface Fault Reference).

     • Zero or more element information items from among the following, in any order:

       • A feature element information item (see 2.7.2 XML Representation of Feature Component).

       • A property element information item (see 2.8.2 XML Representation of Property Component).

       • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.4.3 Mapping Interface Operation's XML Representation to Component Properties

The mapping from the XML Representation of the operation element information item (see 2.4.2 XML Representation of Interface Operation Component) to the properties of the Interface Operation component (see 2.4.1 The Interface Operation Component) is as described in Table 2-4.

2.5.1 The Interface Message Reference Component

A Interface Message Reference component associates a defined element with a message exchanged in an operation. By default, the element is defined in the XML Infoset [XML Information Set].

A message exchange pattern defines a set of placeholder messages that participate in the pattern and assigns them unique message labels within the pattern (e.g. 'In', 'Out'). The purpose of an Interface Message Reference component is to associate an actual message element (XML element declaration or some other declaration (see 3.2 Using Other Schema Languages)) with a message in the pattern, as identified by its message label. Later, when the message exchange pattern is instantiated, messages corresponding to that particular label will follow the element assignment made by the Interface Message Reference component.

The properties of the Interface Message Reference component are as follows:

• {message label} REQUIRED. An xs:NCName. This property identifies the role this message plays in the {message exchange pattern} of the Interface Operation component this message is contained within. The value of this property MUST match the name of a placeholder message defined by the message exchange pattern.

• {direction} REQUIRED. An xs:token with one of the values in or out, indicating whether the message is coming to the service or going from the service, respectively. The direction MUST be the same as the direction of the message identified by the {message label} property in the {message exchange pattern} of the Interface Operation component this is contained within.

• {message content model} REQUIRED. An xs:token with one of the values #any, #none, #other, or #element. A value of #any indicates that the message content is any single element. A value of #none indicates there is no message content. A value of #other indicates that the message content is described by some other extension property that references a declaration in a non-XML extension type system. A value of #element indicates that the message consists of a single element described by the global element declaration referenced by the {element} property. This property is used only when the message is described using an XML based data model.

• {element declaration} OPTIONAL. A reference to an XML element declaration in the {element declarations} property of 2.1.1 The Description Component. This element represents the content or “payload” of the message. When the {message content model} property has the value #any or #none the {element declaration} property MUST be empty.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Interface Operation component that contains this component in its {interface message references} property.

Direction...

Direction  [ show all ]  [ hide all ]

Let Direction be a message direction of either in or out:

Direction ::= inToken | outToken

MessageContentModel...

MessageContentModel  [ show all ]  [ hide all ]

Let MessageContentModel be a message content model of either any, none, other, or element:

MessageContentModel ::= anyToken | noneToken | otherToken | elementToken

InterfaceMessageReference...

InterfaceMessageReference  [ show all ]  [ hide all ]

Let InterfaceMessageReference be the set of all Interface Message Reference components:

InterfaceMessageReference
NestedBase
messageLabel : NCName
direction : Direction
messageContentModel : MessageContentModel
elementDeclaration : OPTIONAL[ID]
messageContentModel = elementToken⇔elementDeclaration≠∅

See NestedBase, NCName, Direction, OPTIONAL, MessageContentModel, ID.

• The message content model is element exactly when the element declaration property is defined.

InterfaceMessageReferenceRI...

InterfaceMessageReferenceRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Message Reference component must exist in the component model.

Let InterfaceMessageReferenceRI express the referential integrity constraints on the Interface Message Reference component:

InterfaceMessageReferenceRI
ComponentModel2
∀InterfaceMessageReference |θInterfaceMessageReference∈interfaceMessageRefComps •
NestedBaseRI∧
elementDeclaration⊆elementDeclIds

See ComponentModel2, InterfaceMessageReference, NestedBaseRI.

• Every Interface Message Reference component satifies the base referential integrity constraints.

• The Element Declaration components of each Interface Message Reference component are contained in the component model.

If a type system not based upon the XML Infoset is in use (as considered in 3.2 Using Other Schema Languages) then additional properties would need to be added to the Interface Message Reference Component (along with extensibility attributes to its XML representation) to allow associating such message types with the message reference.

For each Interface Message Reference component in the {message references} property of an Interface Operation component, its {message label} property MUST be unique.

2.5.2 XML Representation of Interface Message Reference Component

<description>
  <interface>
    <operation>
      <input
            messageLabel="xs:NCName"?
            element="union of xs:QName, xs:token"? >
        <documentation />?
        [ <feature /> | <property /> ]*
      </input>
      <output
            messageLabel="xs:NCName"?
            element="union of xs:QName, xs:token"? >
        <documentation />?
        [ <feature /> | <property /> ]*
      </output>
    </operation>
  </interface>
</description>

The XML representation for an Interface Message Reference component is an element information item with the following Infoset properties:

• A [local name] of input or output

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• Zero or more attribute information items amongst its [attributes] as follows:

  • An OPTIONAL messageLabel attribute information item as described below in 2.5.2.1 messageLabel attribute information item with input or output [owner element].

    If the {message exchange pattern} of the Interface Operation component has only one message with a given value for {direction}, then the messageLabel attribute information item is optional for the XML representation of the Message Reference component with that {direction}.

  • An OPTIONAL element attribute information item as described below in 2.5.2.2 element attribute information item with input or output [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information item amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more feature element information items 2.7.2 XML Representation of Feature Component

     • Zero or more property element information items 2.8.2 XML Representation of Property Component

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.5.3 Mapping Interface Message Reference's XML Representation to Component Properties

The mapping from the XML Representation of the message reference element information item (see 2.5.2 XML Representation of Interface Message Reference Component) to the properties of the Interface Message Reference component (see 2.5.1 The Interface Message Reference Component) is as described in Table 2-5.

2.6.1 The Interface Fault Reference Component

An Interface Fault Reference component associates a defined type, specified by an Interface Fault component, to a fault message exchanged in an operation.

A message exchange pattern defines a set of placeholder messages that participate in the pattern and assigns them unique message labels within the pattern (e.g. 'In', 'Out'). The purpose of an Interface Fault Reference component is to associate an actual message type (XML element declaration or some other declaration (see 3.2 Using Other Schema Languages) for message content, as specified by an Interface Fault component) with a fault message occurring in the pattern. In order to identify the fault message it describes, the Fault Reference component uses the message label of the message the fault is associated with as a key.

The companion specification [WSDL 2.0 Adjuncts] defines two fault patterns that a given message exchange pattern may use. For the pattern fault-replaces-message, the message that the fault relates to identifies the message in place of which the declared fault message will occur. Thus, the fault message will travel in the same direction as the message it replaces in the pattern. For the pattern message-triggers-fault, the message that the fault relates to identifies the message after which the indicated fault may occur, in the opposite direction of the referred to message. That is, the fault message will travel in the opposite direction of the message it comes after in the pattern.

The properties of the Interface Fault Reference component are as follows:

• {interface fault} REQUIRED. An Interface Fault component in the {interface faults} property of the [parent] Interface Operation component's [parent] Interface component, or an Interface component that it directly or indirectly extends. Identifying the Interface Fault component therefore indirectly defines the actual content or payload of the fault message.

• {message label} REQUIRED. An xs:NCName. This property identifies the message this fault relates to among those defined in the {message exchange pattern} property of the Interface Operation component it is contained within. The value of this property MUST match the name of a placeholder message defined by the message exchange pattern.

• {direction} REQUIRED. A xs:token with one of the values in or out, indicating whether the fault is coming to the service or going from the service, respectively. The direction MUST be consistent with the direction implied by the fault rule used in the message exchange pattern of the operation. For example, if the fault rule fault-replaces-message is used, then a fault which refers to an outgoing message would have a {direction} property value of out. On the other hand, if the fault rule message-triggers-fault is used, then a fault which refers to an outgoing message would have a {direction} property value of in as the fault travels in the opposite direction of the message.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Interface Operation component that contains this component in its {interface fault references} property.

InterfaceFaultReference...

InterfaceFaultReference  [ show all ]  [ hide all ]

Let InterfaceFaultReference be the set of all Interface Fault Reference components:

InterfaceFaultReference
NestedBase
interfaceFault : ID
messageLabel : NCName
direction : Direction

See NestedBase, ID, NCName, Direction.

InterfaceFaultReferenceRI...

InterfaceFaultReferenceRI  [ show all ]  [ hide all ]

Each component referenced by a Interface Fault Reference component must exist in the component model.

Let InterfaceFaultReferenceRI express the referential integrity constraints on the Interface Fault Reference component:

InterfaceFaultReferenceRI
ComponentModel2
∀InterfaceFaultReference |θInterfaceFaultReference∈interfaceFaultRefComps •
NestedBaseRI∧
interfaceFault∈interfaceFaultIds

See ComponentModel2, InterfaceFaultReference, NestedBaseRI.

• Every Interface Fault Reference component satifies the base referential integrity constraints.

• The Interface Fault component of each Interface Fault Reference component is contained in the component model.

2.6.2 XML Representation of Interface Fault Reference

<description>
  <interface>
    <operation>
      <infault
            ref="xs:QName"
            messageLabel="xs:NCName"? >
        <documentation />?
        [ <feature /> | <property /> ]*
      </infault>*
      <outfault
            ref="xs:QName"
            messageLabel="xs:NCName"? >
        <documentation />?
        [ <feature /> | <property /> ]*
      </outfault>*
    </operation>
  </interface>
</description>

The XML representation for a Interface Fault Reference component is an element information item with the following Infoset properties:

• A [local name] of infault or outfault

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED ref attribute information item as described below in 2.6.2.1 ref attribute information item with infault, or outfault [owner element].

  • An OPTIONAL messageLabel attribute information item as described below in 2.6.2.2 messageLabel attribute information item with infault, or outfault [owner element].

    If the {message exchange pattern} of the Interface Operation component has only one message with a given value for {direction}, the messageLabel attribute information item is optional for the XML representation of any Interface Fault Reference component with the same value for {direction} (if the fault pattern of the {message exchange pattern} is fault-replaces-message) or of any Fault Reference component with the opposite value for {direction} (if the fault pattern is message-triggers-fault).

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information item amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more feature element information items 2.7.2 XML Representation of Feature Component

     • Zero or more property element information items 2.8.2 XML Representation of Property Component

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.6.3 Mapping Interface Fault Reference's XML Representation to Component Properties

The mapping from the XML Representation of the message reference element information item (see 2.6.2 XML Representation of Interface Fault Reference) to the properties of the Interface Fault Reference component (see 2.6.1 The Interface Fault Reference Component) is as described in Table 2-6.

2.7.1 The Feature Component

A feature component describes an abstract piece of functionality typically associated with the exchange of messages between communicating parties. Although WSDL 2.0 imposes no constraints on the potential scope of such features, examples might include “reliability”, “security”, “correlation”, and “routing”. The presence of a feature component in a WSDL 2.0 description indicates that the service supports the feature and may require a client that interacts with the service to use that feature. Each Feature is identified by its URI.

WSDL 2.0's feature concept is derived from SOAP 1.2's abstract feature concept ([SOAP 1.2 Part 1: Messaging Framework]). Thus, by definition, every SOAP 1.2 abstract feature is also a WSDL 2.0 feature and does not have to be declared as such.

The properties of the Feature component are as follows:

• {uri} REQUIRED. An xs:anyURI. This URI MUST be absolute as defined by [IETF RFC 3986]. This URI SHOULD be dereferenceable to a document that directly or indirectly defines the meaning and use of the Feature that it identifies.

• {required} REQUIRED. An xs:boolean. If the value of this property is true, then the client MUST use the Feature that is identified by the {uri} URI. Otherwise, the client MAY use the Feature that is identified by the {uri} URI. In either case, if the client does use the Feature that is identified by the {uri} URI, then the client MUST obey all semantics implied by the definition of that Feature.

• {parent} REQUIRED. The component that contains this component in its {features} property.

The {uri} property of a Feature component MUST be unique within the {features} property of an Interface, Interface Fault, Interface Operation, Interface Message Reference, Fault Reference, Binding, Binding Fault, Binding Operation, Binding Message Reference, Binding Fault Reference, Service, or Endpoint component.

Feature...

Feature  [ show all ]  [ hide all ]

Let Feature be the set of all Feature components:

Feature
Identifier
uri : AbsoluteURI
required : Boolean
Parent

See AbsoluteURI, Boolean, Parent.

FeatureRI...

FeatureRI  [ show all ]  [ hide all ]

The parent of a Feature MUST be in the component model.

Let FeatureRI express this referential integrity constraint on the Feature component:

FeatureRI
ComponentModel2
∀Feature |θFeature∈featureComps •
ParentRI

See ComponentModel2, Feature, ParentRI.

2.7.1.1 Feature Composition Model

The set of features which are required or available for a given component consists of the combined set of ALL feature declarations applicable to that component. A feature is applicable to a component if:

• it is asserted directly within that component, or

• it is asserted in a containing component, or

• it is asserted in a component referred to by the current component.

Features...

Features  [ show all ]  [ hide all ]

Many of the component types in the component model contain a {features} property, which is a set of Feature components. We refer to these as the declared features of the component. Furthermore, the {features} property is itself a subset of Feature components that are required or available for the given component as determined by the Feature Composition Model. We refer to these as the in-scope features of the component.

Let Features denote these sets of Feature components:

Features
features :ℙID
inScopeFeatures :ℙID
features⊆inScopeFeatures

See ID.

• The in-scope features for a component always include the declared features for that component.

Following these rules, the set of features applicable at each component are as follows:

• Interface component: all features asserted within the interface component.

• Interface Fault component: all features asserted within the interface fault component and those within the [parent] interface component.

• Interface Operation component: all features asserted within the interface operation component and those within the [parent] interface component.

• Interface Message Reference component: all features asserted within the interface message reference component, those within the [parent] interface operation component and those within its [parent] interface component.

• Interface Fault Reference component: all features asserted within the fault reference component, those within the [parent] interface operation component and those within its [parent] interface component.

• Binding component: all features asserted within the binding component and those within the interface component referred to by the binding component (if any).

• Binding Fault component: all features asserted within the binding fault component, those within the [parent] binding component, those within the corresponding interface fault component, and those within the interface component referred to by the binding component (if any).

• Binding Operation component: all features asserted within the binding operation component, those within the [parent] binding component, those within the corresponding interface operation component, and those within the interface component referred to by the binding component.

• Binding Message Reference component: all features asserted within the binding message reference component, those within the [parent] binding operation component, those within its [parent] binding component, those within the corresponding message reference component, and those within the interface component referred to by the binding component.

• Binding Fault Reference component: all features asserted within the binding fault reference component, those within the [parent] binding operation component, those within its [parent] binding component, those within the corresponding fault reference component, and those within the interface component referred to by the binding component.

If a given feature is asserted at multiple locations, then the value of that feature at a particular component is determined by the conjunction of all the constraints implied by its asserted values. If a feature is not required then it may or may not be engaged, but if a feature is required then it must be engaged. Therefore, the conjunction of a required value and a non-required value is a required value. A composed feature is required if and only if at least one of its asserted values is required. This rule may be summarized as "true trumps".

2.7.1.1.1 Example of Feature Composition Model

In the following example, the depositFunds operation on the BankService has to be used with the ISO9001 , the notarization and the secure-channel features; they are all in scope. The fact that the notarization feature is declared both in the operation and in the binding has no effect.

<description targetNamespace="http://example.com/bank"
     xmlns=http://www.w3.org/2005/05/wsdl
     xmlns:ns1="http://example.com/bank">
  <interface name="ns1:Bank">
    <!-- All implementations of this interface must be secure -->
    <feature uri="http://example.com/secure-channel"
             required="true"/>
    <operation name="withdrawFunds">
      <!-- This operation must have ACID properties -->
      <feature uri="http://example.com/transaction"
               required="true"/>
      ...
    </operation>
    <operation name="depositFunds">
      <!-- This operation requires notarization -->
      <feature uri="http://example.com/notarization"
               required="true"/>
      ...
    </operation>
  </interface>

  <binding name="ns1:BankSOAPBinding">
    <!-- This particular binding requires ISO9001
         compliance to be verifiable -->
    <feature uri="http://example.com/ISO9001"
             required="true"/>
    <!-- This binding also requires notarization -->
    <feature uri="http://example.com/notarization"
             required="true"/>
  </binding>

  <service name="ns1:BankService"
           interface="tns:Bank">
    <endpoint binding="ns1:BankSOAPBinding">
      ...
    </endpoint>
  </service>
</description>

2.7.2 XML Representation of Feature Component

<feature
      uri="xs:anyURI" 
      required="xs:boolean"? >
  <documentation />?
</feature>

The XML representation for a Feature component is an element information item with the following Infoset properties:

• A [local name] of feature

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED uri attribute information item as described below in 2.7.2.1 uri attribute information item with feature [owner element].

  • An OPTIONAL required attribute information item as described below in 2.7.2.2 required attribute information item with feature [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information items amongst its [children], in order as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

2.7.3 Mapping Feature's XML Representation to Component Properties

The mapping from the XML Representation of the feature element information item (see 2.7.2 XML Representation of Feature Component) to the properties of the Feature component (see 2.7.1 The Feature Component) is as described in Table 2-7.

2.8.1 The Property Component

A “property” in the Features and Properties architecture represents a named runtime value which affects the behavior of some aspect of a Web service interaction, much like an environment variable. For example, a reliable messaging SOAP module may specify a property to control the number of retries in the case of network failure. WSDL 2.0 documents may specify the value constraints for these properties by referring to a Schema type, or by specifying a particular value. Properties, and hence property values, can be shared amongst features/bindings/modules, and are named with URIs precisely to allow this type of sharing.

The properties of the Property component are as follows:

• {uri} REQUIRED. An xs:anyURI. This URI MUST be absolute as defined by [IETF RFC 3986]. This URI SHOULD be dereferenceable to a document that directly or indirectly defines the meaning and use of the Property that it identifies.

• {value constraint} OPTIONAL. A reference to a type definition in the {type definitions} property of 2.1.1 The Description Component constraining the value of the property, or the token #value if the {value} property is not empty.

• {value} OPTIONAL. The value of the property, an ordered list of child information items, as specified by the [children] property of element information items in [XML Information Set].

• {parent} REQUIRED. The component that contains this component in its {properties} property.

The {uri} property of a Property component MUST be unique within the {properties} property of an Interface, Interface Fault, Interface Operation, Interface Message Reference, Fault Reference, Binding, Binding Fault, Binding Operation, Binding Message Reference, Binding Fault Reference, Service, or Endpoint component.

ValueConstraint...

ValueConstraint  [ show all ]  [ hide all ]

Let ValueConstraint be the set of value constraints for Property components:

ValueConstraint ::= typeDefinitionId〈〈ID〉〉| valueToken

See ID.

• A value constraint is either a Type Definition component which defines the set of allowable values, or the token #value which indicates that the value is given by the contents of the value property of the Property component.

ElementChildren...

ElementChildren  [ show all ]  [ hide all ]

Let ElementChildren be the set of all allowable values of the [children] property of an XML Infoset element information item:

[ElementChildren]

Property...

Property  [ show all ]  [ hide all ]

Let Property be the set of all Property components:

Property
Identifier
uri : AbsoluteURI
valueConstraint : OPTIONAL[ValueConstraint]
value : OPTIONAL[ElementChildren]
Parent
valueConstraint = {valueToken}⇔value≠∅

See Identifier, AbsoluteURI, OPTIONAL, ValueConstraint, ElementChildren, Parent.

• The value is constrained to be an explicitly given value exactly when the value property is defined.

PropertyRI...

PropertyRI  [ show all ]  [ hide all ]

Each component referenced by a Property component must exist in the component model.

Let PropertyRI express the referential integrity constraints on the Property component:

PropertyRI
ComponentModel2
∀Property; y : ID |θProperty∈propertyComps •
valueConstraint = {typeDefinitionId(y)}⇒y∈typeDefIds∧
ParentRI

See ComponentModel2.

• If the value constraint of a Property component is a type definition, then the Type Definition component is contained in the component model.

• The parent of each Property component is contained in the component model.

If a type system not based upon the XML Infoset is in use (as considered in 3.2 Using Other Schema Languages) then additional properties would need to be added to the Property Component (along with extensibility attributes to its XML representation) to allow using such a type system to describe values and constraints for properties.

2.8.1.1 Property Composition Model

At runtime, the behavior of features, (SOAP) modules and bindings may be affected by the values of in-scope properties. Properties combine into a virtual “execution context” which maps property names (URIs) to constraints. Each property URI MAY therefore be associated with AT MOST one property constraint for a given interaction.

The set of properties which are required or available for a given component consists of the combined set of ALL property declarations applicable to that component. A property is applicable to a component if:

• it is asserted directly within that component, or

• it is asserted in a containing component, or

• it is asserted in a component referred to by the current component.

Properties...

Properties  [ show all ]  [ hide all ]

Many of the component types in the component model contain a {properties} property, which is a set of Property components. We refer to these as the declared properties of the component. Furthermore, the {properties} property is itself a subset of Property components that are required or available for the given component as determined by the Property Composition Model. We refer to these as the in-scope properties of the component.

Let Properties denote these sets of Property components:

Properties
properties :ℙID
inScopeProperties :ℙID
properties⊆inScopeProperties

See ID.

• The in-scope properties for a component always include the declared properties for that component.

Following these rules, the set of properties applicable at each component are as follows:

• Interface component: all properties asserted within the interface component.

• Interface Fault component: all properties asserted within the interface fault component and those within the [parent] interface component.

• Interface Operation component: all properties asserted within the interface operation component and those within the [parent] interface component.

• Interface Message Reference component: all properties asserted within the message reference component, those within the [parent] interface operation component and those within its [parent] interface component.

• Binding component: all properties asserted within the binding component and those within the interface component referred to by the binding component (if any).

• Binding Fault component: all properties asserted within the binding fault component, those within the [parent] binding component, those within the corresponding interface fault component, and those within the interface component referred to by the binding component (if any).

• Binding Operation component: all properties asserted within the binding operation component, those within the [parent] binding component, those within the corresponding interface operation component, and those within the interface component referred to by the binding component.

• Binding Message Reference component: all properties asserted within the binding message reference component, those within the [parent] binding operation component, those within its [parent] binding component, those within the corresponding interface message reference component, and those within the interface component referred to by the binding component.

• Binding Fault Reference component: all properties asserted within the binding fault reference component, those within the [parent] binding operation component, those within its [parent] binding component, those within the corresponding fault reference component, and those within the interface component referred to by the binding component.

Note that, in the text above, “property constraint” (or, simply, “constraint”) is used to mean EITHER a constraint inside a property component OR a value , since value may be considered a special case of constraint .

If a given property is asserted at multiple locations, then the value of that property at a particular component is determined by the conjunction of all the constraints of its in-scope property components. A property constraint asserts that, for a given interaction, the value of a property is either a specified value or belongs to a specified set of values. A specified value may be regarded as a singleton set, so in both cases a property constraint corresponds to an assertion that the property value belongs to some set. The conjunction of all the constraints associated with the in-scope properties is an assertion that the property value belongs to each of the associated sets, or equivalently, that the value belongs to the intersection of all the associated sets. If the intersection of the associated sets is empty, then the property constraints are mutually incompatible, and the composition is invalid. Therefore, the intersection of the associated sets SHOULD NOT be empty.

Note:

The reason that we phrase the requirement for a non-empty intersection as SHOULD rather than MUST, is that in general, it may be computationally difficult to determine by inspection of the type definitions that the intersection of two or more value sets is empty. Therefore, it is not a strict validity requirement that the intersection of the value sets be non-empty. An empty intersection will always result in failure of the service at run-time.

However, it is in general feasible to test specified values for either equality or membership in value sets. All specified values MUST be equal and belong to each specified value set.

2.8.2 XML Representation of Property Component

<property
      uri="xs:anyURI" >
  <documentation />?
  [ <value /> | <constraint /> ]?
</property>

The XML representation for a Property component is an element information item with the following Infoset properties:

• A [local name] of property

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED uri attribute information item as described below in 2.8.2.1 uri attribute information item with property [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information items amongst its [children], in order as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. One OPTIONAL element information item from among the following:

     • A value element information item as described in 2.8.2.2 value element information item with property [parent]

     • A constraint element information item as described in 2.8.2.3 constraint element information item with property [parent]

  3. Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

<property>
  <value>
    xs:anyType
  </value>
</property>

<property>
  <constraint>
    xs:QName
  </constraint>
</property>

2.8.3 Mapping Property's XML Representation to Component Properties

The mapping from the XML Representation of the property element information item (see 2.8.2 XML Representation of Property Component) to the properties of the Property component (see 2.8.1 The Property Component) is as described in Table 2-8.

2.9.1 The Binding Component

A Binding component describes a concrete message format and transmission protocol which may be used to define an endpoint (see 2.15 Endpoint). That is, a Binding component defines the implementation details necessary to access the service.

Binding components can be used to describe such information in a re-usable manner for any interface or specifically for a given interface. Furthermore, binding information MAY be specified on a per-operation basis (see 2.11.1 The Binding Operation Component) within an interface in addition to across all operations of an interface.

If a Binding component specifies any operation-specific binding details (by including Binding Operation components) or any fault binding details (by including Binding Fault components) then it MUST specify an interface the Binding component applies to, so as to indicate which interface the operations come from.

Conversely, a Binding component which omits any operation-specific binding details and any fault binding details MAY omit specifying an interface. Binding components that do not specify an interface MAY be used to specify operation-independent binding details for Service components with different interfaces. That is, such Binding components are reusable across one or more interfaces.

No concrete binding details are given in this specification. The companion specification, WSDL (Version 2.0): Adjuncts [WSDL 2.0 Adjuncts] defines such bindings for SOAP 1.2 [SOAP 1.2 Part 1: Messaging Framework] and HTTP [IETF RFC 2616]. Other specifications MAY define additional binding details. Such specifications are expected to annotate the Binding component (and its sub-components) with additional properties and specify the mapping from the XML representation to those properties.

A Binding component which defines bindings for an Interface component MUST define bindings for all the operations of that Interface component. The bindings may occur via defaulting rules which allow one to specify default bindings for all operations (see, for example [WSDL 2.0 Adjuncts]) or by directly listing each Operation component of the Interface component and defining bindings for them. Thus, it is an error for a Binding component to not define bindings for all the Operation components of the Interface component for which the Binding component purportedly defines bindings for.

Bindings are named constructs and can be referred to by QName (see 2.19 QName resolution). For instance, Endpoint components refer to bindings in this way.

The properties of the Binding component are as follows:

• {name} REQUIRED. An xs:QName.

• {interface} OPTIONAL. An Interface component indicating the interface for which binding information is being specified.

• {type} REQUIRED. An xs:anyURI. This URI MUST be absolute as defined by [IETF RFC 3986]. The value of this URI indicates what kind of concrete binding details are contained within this Binding component. Specifications (such as [WSDL 2.0 Adjuncts] ) that define such concrete binding details MUST specify appropriate values for this property. The value of this property MAY be the namespace name of the extension elements or attributes which define those concrete binding details.

• {binding faults} OPTIONAL. A set of Binding Fault components.

• {binding operations} OPTIONAL. A set of Binding Operation components.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

Binding...

Binding  [ show all ]  [ hide all ]

Let Binding be the set of all Binding components:

Binding
Base
name : QName
interface : OPTIONAL[ID]
type : AbsoluteURI
bindingFaults :ℙID
bindingOperations :ℙID

See Base, QName, OPTIONAL, ID, AbsoluteURI.

BindingRI...

BindingRI  [ show all ]  [ hide all ]

Each component referenced by a Binding component must exist in the component model.

Let BindingRI express the referential integrity constraints on the Binding component:

BindingRI
ComponentModel2
∀Binding |θBinding∈bindingComps •
BaseRI∧
interface⊆interfaceIds∧
bindingFaults⊆bindingFaultIds∧
bindingOperations⊆bindingOpIds

See ComponentModel2, Binding, BaseRI.

• Every Binding component satifies the base referential integrity constraints.

• The Interface component of each Binding component is contained in the component model.

• The Binding Fault components of each Binding component are contained in the component model.

• The Binding Operation components of each Binding component are contained in the component model.

For each Binding component in the {bindings} property of a description container, the {name} property MUST be unique.

2.9.2 XML Representation of Binding Component

<description>
  <binding
        name="xs:NCName" 
        interface="xs:QName"?
        type="xs:anyURI" >
    <documentation />?
    [ <fault /> | <operation /> | <feature /> | <property /> ]*
  </binding>
</description>

The XML representation for a Binding component is an element information item with the following Infoset properties:

• A [local name] of binding

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• Two or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED name attribute information item as described below in 2.9.2.1 name attribute information item with binding [owner element].

  • An OPTIONAL interface attribute information item as described below in 2.9.2.2 interface attribute information item with binding [owner element].

  • An REQUIRED type attribute information item as described below in 2.9.2.3 type attribute information item with binding [owner element].

  • Zero or more namespace qualified attribute information items whgse [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information items amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more fault element information items (see 2.10.2 XML Representation of Binding Fault Component).

     • Zero or more operation element information items (see 2.11.2 XML Representation of Binding Operation Component).

     • Zero or more feature element information items (see 2.7.2 XML Representation of Feature Component).

     • Zero or more property element information items (see 2.8.2 XML Representation of Property Component).

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl". Such element information items are considered to be binding extension elements(see 2.9.2.4 Binding extension elements).

2.9.3 Mapping Binding's XML Representation to Component Properties

The mapping from the XML Representation of the binding element information item (see 2.9.2 XML Representation of Binding Component) to the properties of the Binding component (see 2.9.1 The Binding Component) is as described in Table 2-9.

2.10.1 The Binding Fault Component

A Binding Fault component describes a concrete binding of a particular fault within an interface to a particular concrete message format. A particular fault of an interface is uniquely identified by its {name} property.

Note that the fault does not occur by itself - it occurs as part of a message exchange as defined by an Interface Operation component (and its binding counterpart the Binding Operation component). Thus, the fault binding information specified in a Binding Fault component describes how faults that occur within a message exchange of an operation will be formatted and carried in the transport.

The properties of the Binding Fault component are as follows:

• {interface fault} REQUIRED. An Interface Fault component in the {interface faults} property of the Interface component identified by the {interface} property of the [parent] Binding component, or an Interface component that that Interface component directly or indirectly extends. This is the Interface Fault component for which binding information is being specified.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Binding component that contains this component in its {binding faults} property.

BindingFault...

BindingFault  [ show all ]  [ hide all ]

Let BindingFault be the set of all Binding Fault components:

BindingFault
NestedBase
faultReference : ID

See NestedBase, ID.

BindingFaultRI...

BindingFaultRI  [ show all ]  [ hide all ]

Each component referenced by a Binding Fault component must exist in the component model.

Let BindingFaultRI express the referential integrity constraints on the Binding Fault component:

BindingFaultRI
ComponentModel2
∀BindingFault |θBindingFault∈bindingFaultComps •
NestedBaseRI∧
faultReference∈interfaceFaultIds

See ComponentModel2, BindingFault, NestedBaseRI.

• Every Binding Fault component satifies the base referential integrity constraints.

• The Interface Fault component of each Binding Fault component is contained in the component model.

For each Binding Fault component in the {binding faults} property of a Binding component, the {interace fault} property MUST be unique. That is, one cannot define multiple bindings for the same fault within a given Binding component.

2.10.2 XML Representation of Binding Fault Component

<description>
  <binding>
    <fault
          ref="xs:QName" >
      <documentation />?
      [ <feature /> | <property /> ]*
    </fault>
  </binding>
</description>

The XML representation for a Binding Fault component is an element information item with the following Infoset properties:

• A [local name] of fault

• A [namespace name] of "http://www.w3.org/2005/05/wsdl"

• One or more attribute information items amongst its [attributes] as follows:

  • A REQUIRED ref attribute information item as described below in 2.10.2.1 ref attribute information item with fault [owner element].

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl".

• Zero or more element information item amongst its [children], in order, as follows:

  1. An OPTIONAL documentation element information item (see 5. Documentation).

  2. Zero or more element information items from among the following, in any order:

     • Zero or more feature element information items 2.7.2 XML Representation of Feature Component

     • Zero or more property element information items 2.8.2 XML Representation of Property Component

     • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2005/05/wsdl". Such element information items are considered to be binding fault extension elements as described below (see 2.10.2.2 Binding Fault extension elements).

2.10.3 Mapping Binding Fault's XML Representation to Component Properties

The mapping from the XML Representation of the fault element information item (see 2.10.2 XML Representation of Binding Fault Component) to the properties of the Binding Fault component (see 2.10.1 The Binding Fault Component) is as described in Table 2-10.

2.11.1 The Binding Operation Component

The Binding Operation component describes the concrete message format(s) and protocol interaction(s) associated with a particular interface operation for a given endpoint. A particular operation of an interface is uniquely identified by its {name} property.

The properties of the Binding Operation component are as follows:

• {interface operation} REQUIRED. An Interface Operation component in the {interface operations} property of the Interface component identified by the {interface} property of the [parent] Binding component, or an Interface component that that Interface component directly or indirectly extends. This is the Interface Operation component for which binding information is being specified.

• {binding message references} OPTIONAL. A set of Binding Message Reference components.

  Editorial note: TODO - Editorial fix ME28	20050503
  This will be so counter-intuitive for WSDL 1.1 readers that it bears repeating the motivation for this in 2.9.1.

• {binding fault references} OPTIONAL. A set of Binding Fault Reference components.

• {features} OPTIONAL. A set of Feature components.

• {properties} OPTIONAL. A set of Property components.

• {parent} REQUIRED. The Binding component that contains this component in its {binding operations} property.

BindingOperation...

BindingOperation  [ show all ]  [ hide all ]

Let BindingOperation be the set of all Binding Operation components:

BindingOperation
NestedBase
interfaceOperation : ID
bindingMessageReferences :ℙID
bindingFaultReferences :ℙID

See NestedBase, ID.