- Appendix A contains the full
listing of the WSDL ontology,
- Appendix B contains formal mapping
tables defining the transformation from a WSDL component model to
RDF data.
2. WSDL Ontology
This section describes the OWL ontology for WSDL, comparing it
to the WSDL component model defined in <a
href="#todo"> WSDL2 [
WSDL 2.0 Core
</a>. Language ].
While the text in this section may imply how the components might
be mapped to their RDF representation, such implications are not
intended to be normative; for
normative, as this section aims to be a
verbose explanation of the mapping. For the formal normative
mappings, see Appendix B .
This section may also briefly touch on some differences between
the OWL ontology and the component model, but for the full account
and rationalization rationales of these differences see section 3
4 .
The ontological equivalents for the core WSDL components defined
in <a href="#todo"> WSDL2
[ WSDL 2.0 Core Language ] are
described in section 2.1 . All these components
are extensible, so section 2.2 describes
how deleted text: features, properties and extensions are mapped to
RDF. The following sections, from 2.3 to 2.7, describe the
ontological equivalents for the various adjuncts specified in
<a href="#todo"> WSDL2
[ WSDL 2.0 Adjuncts </a>. ].
2.1 Core WSDL Components
All the main components of WSDL are represented as classes in
the WSDL ontology: Description ,
Interface , Binding and
Service , as described in the following subsections.
This means that every interface, binding and service described by
WSDL will be mapped to a single instance in the RDF representation,
linked from the instance mapped from the top-level description Description component.
All the components in WSDL can contain documentation. Such
documentation consists of human-readable text and
machine-processible elements and attributes, but it isn't modeled
in more detail in WSDL 2. Therefore in the RDF mapping we represent
documentation as XML literals, which should consist of the
wsdl:documentation element and all its children. The
literal is attached to the appropriate component in the RDF
representation using the property documentation .
Ednote
2.1.1 Description class
The top-level WSDL component — description — is
mapped to a single instance of the class Description ,
which uses the properties interface , binding
deleted text: </code>, <code> service </code>,
<code> typeDefinition and elementDeclaration service to point to its contents, i.e. all
the interfaces, bindings, services, type
definitions bindings and
services. Note that since we don't
model element declarations present
(or included or imported) in this description. and type definitions further than just the QNames, we
also don't reference them from the Description instance. This also means that while all WSDL component
models implicitly contain all XML Schema simple type definitions,
the RDF mapping does not show them.
Note that a mapping of a single WSDL document (together with any
imports or includes) will always result in a single instance of the
Description class. However, there can be multiple
individuals of the class Description in a knowledge
base that contains the information from multiple WSDL documents.
The core WSDL specification does not consider the case of combining
multiple independent WSDL documents and deleted text: that it doesn't mandate that independent
documents describe consistently components with the same name. This
is, however, an assumption when combining multiple WSDL documents
in the RDF representation. See more on this
point in section
4.2 .
2.1.2 Interface classes
All WSDL interfaces are represented in RDF as instances of the
Interface class. WSDL interfaces can extend other
interfaces, which is indicated by the property
extensionOf . Interfaces may have operations and
faults, represented as instances of InterfaceOperation
and InterfaceFault classes and each pointed to with
the properties interfaceOperation and
interfaceFault , respectively.
There are a number of properties applicable to
InterfaceOperation instances:
messageExchangePattern property points to an
instance of the class MessageExchangePattern and thus
indicates the message exchange pattern (MEP) used by this
operation; there can be only one MEP on one operationoperationStyle property points to an instance of
the class OperationStyle and indicates that the
operation adheres to the given style; there can be multiple
operation styles on a single operationinterfaceMessageReference and
interfaceFaultReference properties point to instances
of InterfaceMessageReference and
InterfaceFaultReference classes respectively, which
are described later.
Interface faults, in turn, only contain a single pointer to an
element declaration, represented by the property
elementDeclaration and pointing to a
QName instance.
Interface message references and interface fault references can
indicate their direction — input message references and input
fault references all belong to the class InputMessage
and output message references and output fault references all
belong to the class OutputMessage . Further, both
message references and fault references indicate the appropriate
message labels (instances of MessageLabel ,
representing particular messages in the operation's MEP) using the
property messageLabel . (In section
2.3 we describe how message exchange patterns are modeled in
our RDF mapping.)
Furthermore, interface message references point to element
declarations using the property elementDeclaration and
they specify their message content model with the property
messageContentModel , indicating one of the four
possible instances of the class MessageContentModel .
Interface And
finally interface fault references,
on the other hand, references
refer to their interface faults directly using the property
interfaceFault .
2.1.3 Binding classes
WSDL bindings are represented in RDF as instances of the class
Binding . To indicate a particular interface for which
binding information is specified with this WSDL binding, the
particular Interface instance is pointed to using the
property interface . Binding types (for example SOAP
binding or HTTP binding, as specified in <a href="#todo"> WSDL2 adjuncts
[ WSDL 2.0 Adjuncts ) ]) are themselves
classes in RDF, so a binding type is indicated by belonging to the
appropriate class (using the property rdf:type ).
As the structure of bindings follows the structure of
interfaces, we represent binding operations and faults using the
classes BindingOperation and BindingFault
respectively. The parent binding points to them using the similarly
named properties bindingOperation and
bindingFault . Binding operations further contain
message and fault references, represented as instances of the
classes BindingMessageReference and
BindingFaultReference , and pointed to by the
properties bindingMessageReference and
bindingFaultReference .
Within this structure, each component points to the appropriate
component from the interface structure, i.e. binding operations
point to interface operations, binding faults respectively point to
interface faults and binding message and fault references point to
interface message and fault references. To provide these pointers,
we reuse the same properties that are used within the interface
structure, i.e. interfaceOperation ,
interfaceFault ,
interfaceMessageReference and
interfaceFaultReference .
Finally, each component is supposed to contain extensions that
provide the actual binding information. For the description of
handling such extensions see section 2.2
and for the specific bindings included in WSDL 2 specification, see
sections 2.6 and 2.7 .
2.1.4 Service classes
WSDL services are represented in RDF as instances of the class
Service . Each instance must point to a single
interface; for this purpose we reuse the property
interface . Also, each service has one or more
endpoints, to which it points using the property
endpoint .
Endpoints are represented as instances of the class
Endpoint , with two notable properties: mandatory
single binding points to the binding used by this
endpoint, and optional single address points to the
network resource which actually offers the service.
2.2 Handling Features, Properties and Generic
Extensions
In order to enable evolution and reusability of the language,
WSDL 2 allows extensions on all components. In fact, there are
multiple types of extensibility in WSDL 2: extension points,
abstract features and properties, and generic XML-based
extensions.
Extension points are those places in WSDL where a number of
options is defined by the WSDL 2 specification, but the list is
open. For example, interface operations follow message exchange
patterns (MEPs), and while WSDL 2 provides a list of eight MEPs,
new ones can be specified by WSDL 2 users. Similarly, WSDL 2
specifies two bindings (SOAP and HTTP), but more bindings are
expected to be specified in the future, either by the
WS-Description Working Group or by any interested third parties.
Often, extension points use URIs to refer to the various options,
but often the extensions introduce data that needs to be modeled in
the RDF representation of WSDL 2, in which case it is the
responsibility of the extension designers to describe their
mappings to RDF.
Features and properties represent abstract pieces of
functionality and their run-time parameters. Mostly, features and
properties simply use URIs to identify their semantics, and this
easily translates into RDF, as described below in section 2.2.1 .
Apart from the envisioned extensibility points and the abstract
functionality extensibility using features, WSDL 2 allows the XML
WSDL documents to contain any "foreign" elements and attributes, so
that unexpected extensions, even ones that change the core WSDL
semantics, can also be realized. Mapping such extensions to RDF is
described in section 2.2.2 .
2.2.1 Features and properties
Every feature component is mapped to RDF as an instance of the
class Feature . This instance is identified by the
feature's IRI, i.e. the value of the {ref} property of the feature
component.
Features can be required or optional. In RDF, this is indicated
by the property that points from the feature's parent component to
the feature — it is either the requiresFeature
or the offersFeature property.
Property components in WSDL 2 serve to specify or constrain the
value that a property can have at run time. As one of the few
naming differences between the RDF representation and the WSDL 2
component model, the property components are represented as
instances of the class PropertyValue , pointed to from
the property's parent component using the
propertyValue RDF property.
Every PropertyValue instance points to the actual
property whose value it specifies, using the RDF property named
property . PropertyValue instances also
either specify the actual value of the property (using the RDF
property propertyActualValue ) or they constrain the
possible values of the property using a type definition identified
by its QName (referenced from the
PropertyValue instance by the RDF property
propertyValueType ).
2.2.2 Generic extensions
The actual meaning of general extensions is, by definition,
unknown to the WSDL specification, and it is equally unknown to the
RDF mapping. Therefore every extension should specify how it is
mapped to RDF. For example, the SOAP and HTTP bindings in WSDL 2
add many properties to the core binding components and this
document defines how these particular properties are expressed in
RDF. The mapping of extensions to RDF therefore depends on the
understanding of those extensions. This section describes how
unknown extensions are handled when mapping a WSDL document into
RDF.
In WSDL 2, extensions can be marked as mandatory (or required).
Such extensions may alter the semantics of the extended components
in ways that invalidate the existing semantics. Since the RDF
representation of WSDL intends to represent the semantics of the
WSDL data, components with deleted
text: unknown required
extensions must be mapped to RDF according to the rules of the
extension, not according to the rules specified in this document.
If a processor that does the mapping of a
WSDL document to RDF does not understand a particular mandatory
extension, it must not map the component that contains that
extension into any generic RDF representation, in other words the
component will not be present in the resulting RDF data.
This is to avoid confusing processors that don't understand a
mandatory extension — RDF encourages the principle of
ignoring the unknown parts of an RDF graph (partial understanding)
and there is no agreed mechanism of marking some parts as
mandatory, therefore if we decided to map the known WSDL according
to our rules and add the mandatory unknown extensions in the graph,
they could be ignored by some RDF processors, violating
their the mandatoriness.
Finally unknown optional extensions (not mandatory) can be
represented in the RDF representation using the properties
extensionElement and extensionAttribute .
Extension elements are represented as XML literals containing the
whole extension XML elements (and should also include all the
in-scope namespaces and the XML base); extension attributes are
represented as instances of the class
ExtensionAttribute , which in turn have a name
(property attributeName pointing to a
QName ) and a value (property rdf:value
pointing to a literal containing the attribute value).
Such representation of unknown optional extensions is not
intended to be used by processors that understand those extensions;
instead such processors should reinterpret the XML literals and map
them into the appropriate RDF extensions of the rest of the RDF
representation.
2.3 Message Exchange Patterns
WSDL 2 defines an extensible set of message exchange patterns
(MEPs). There are 8 predefined MEPs, each following one of the
three predefined fault propagation rules. Every WSDL MEP defines a
set of message labels by which message references in operations can
position themselves within the pattern.
In the RDF representation of WSDL, message exchange patterns are
represented as instances of the class
MessageExchangePattern . The three predefined fault
propagation rules are disjoint subclasses of that class, named
NoFaults , FaultReplacesMessage and
MessageTriggersFault .
All MEPs are identified by IRIs, and the RDF ontology for WSDL
only puts the MEPs in the correct classes; for example
http://www.w3.org/2005/08/wsdl/in-only
http://www.w3.org/2006/01/wsdl/in-only is
an instance of the class NoFaults . The message
labels, however, are plain string names, and the RDF ontology for
WSDL gives each of them an IRI formed by the MEP IRI, the hash sign
'#' and the actual message label, and these IRIs are referenced
from the MEPs with the property definesMessageLabel .
Any newly created MEPs should also provide URIs IRIs for the
message labels, as the RDF mapping depends on being able to
identify the message labels on interface message references.
2.4 Predefined Extensions
WSDL 2 Adjuncts contain a single predefined extension, called
Operation Safety, which adds a property to interface operation
components to indicate whether an interface operation is known to
be safe in terms of <a
href="#todo"> [ Web Architecture </a>. ].
In the RDF representation of WSDL, we introduce the class
SafeInteraction — any
InterfaceOperation instance that is also a
SafeInteraction is asserted to be safe.
2.5 Operation Styles
WSDL 2 predefines 3 operation styles — RPC style, IRI
style and Multipart style. These styles are identified with their
IRIs, which the RDF ontology makes instances of the class
OperationStyle .
The RPC style additionally introduces the property {rpc
signature}, which is represented in RDF using the property
signature , whose value is a literal whose datatype is
the signature type defined by WSDL 2. The signature
property can be attached to interface operations following the RPC
style to indicate the parameter order for the operation.
2.6 SOAP Binding
WSDL bindings that bind to SOAP are identified (using the
property rdf:type ) as instances of the class
http://www.w3.org/2005/08/wsdl/soap http://www.w3.org/2006/01/wsdl/soap .
Every such binding must indicate the SOAP version that it uses,
this is done with the property version (with a value
"1.2", for example, meaning SOAP version 1.2). Every binding also
must specify with the property protocol the underlying
protocol that is uses.
initial message, using the property
action .
Each Binding faults in the SOAP binding operation must can
specify two properties — fault code
and fault subcodes. Both fault code and subcodes are QNames, and
they are pointed to using the properties faultCode and faultSubcode .The
latter is repeated for each subcode that the binding fault
specifies.
At any level within a SOAP binding,
components can declare the use of
a SOAP message exchange pattern it
uses module. Required modules are
pointed to using the property requiresSOAPModule and optional modules are pointed to using the
property offersSOAPModule — both of these properties point directly from the
appropriate parent component to the SOAP module, as identified by
its URI (parameter {ref} of the SOAP
Module component).
Message references and faults in SOAP
bindings can further declare that they include specific SOAP
headers. To do this, the property header can point to
an instance of the class SOAPHeader ,which
then uses the property elementDeclaration to specify the exact element that represents the header.
Instances of SOAPHeader can also
belong to the class MustUnderstandSOAPHeader ,which means that this SOAP header will be marked as
mandatory (mustUnderstand="true") in the message.
Apart from these SOAP-binding-specific properties, the SOAP
specification binding reuses underlying protocol properties, for
example some HTTP binding properties when the underlying
protocol is pointed
HTTP. The following section describes the
HTTP binding properties.
2.7 HTTP
Binding
WSDL bindings that bind to
using HTTP are
identified as instances of the property class
soapMEP http://www.w3.org/2006/01/wsdl/http . The
ontology also introduces HTTP bindings that make use of HTTP cookies are further
identified as instances of the class SOAPMessageExchangePattern HTTPBindingWithCookies .Every HTTP binding must specify the HTTP version in use,
which is done with the property version that
contains all (in a different
namespace from the property version in
the SOAP MEPs. binding), for example HTTP/1.1 is specified with the
value "1.1".
SOAP HTTP
binding operations can specify a number of HTTP parameters:
operation-specific location, HTTP method, input and output and
fault serialization, and query parameter separator. These
parameters are represented in RDF with the properties
location
,method
,inputSerialization
,outputSerialization
,faultSerialization
and queryParameterSeparator .The values of all these properties are literals, same as
in the XML syntax of WSDL.
Message references and faults in an HTTP
binding can specify the use of extra HTTP headers by pointing to a
QName with the property header .Message
references and fault references in HTTP binding operations
can also specify the value
transfer coding using the property
transferCoding
with a literal string value, as in the XML
representation. Finally, faults can further specify the HTTP status
code they will be accompanies with, using the property
errorCode .
HTTP bindings can also specify access
authentication parameters, in particular authentication type and
realm. These parameters are reflected with the properties
authenticationType
and authenticationRealm with string values.
3. Example WSDL document in
RDF form
The following is a listing of the
action parameter (known RDF form of the WSDL description of the initial GreatH
Web Service (listed as SOAP
action) example 2-1) from the WSDL
2.0 primer (in triple notation):
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix wsdl: <http://www.w3.org/2006/01/wsdl> .
@prefix rwsdl: <http://www.w3.org/2005/10/wsdl-rdf#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.description()>
a rwsdl:Description ;
rwsdl:interface <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ;
rwsdl:binding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)> ;
rwsdl:service <http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)>
a rwsdl:Interface ;
rwsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> ;
rwsdl:interfaceOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)>
a rwsdl:InterfaceFault ;
rwsdl:elementDeclaration _:L9C14 .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)>
a rwsdl:InterfaceFaultReference ;
a rwsdl:OutputMessage;
rwsdl:messageLabel <>;
rwsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)>
a rwsdl:InterfaceMessageReference ;
a rwsdl:InputMessage;
rwsdl:elementDeclaration _:L22C18 ;
rwsdl:messageLabel <>;
rwsdl:messageContentModel rwsdl:element .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)>
a rwsdl:InterfaceMessageReference ;
a rwsdl:OutputMessage;
rwsdl:elementDeclaration _:L32C18 ;
rwsdl:messageLabel <>;
rwsdl:messageContentModel rwsdl:element .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)>
a rwsdl:InterfaceOperation ;
rwsdl:messageExchangePattern <http://www.w3.org/2004/03/wsdl/in-out> .
rwsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)> ;
rwsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)> ;
rwsdl:interfaceFaultReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)> ;
<http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)>
a rwsdl:Binding ;
a <http://www.w3.org/2006/01/wsdl/soap>;
rwsdl:interface <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ;
rwsdl:bindingFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)> ;
rwsdl:bindingOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)>
a rwsdl:BindingFault ;
rwsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)>
a rwsdl:BindingOperation ;
rwsdl:interfaceOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)>
a rwsdl:Service ;
rwsdl:interface <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> .
rwsdl:endpoint <http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)> ;
<http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)>
a rwsdl:Endpoint ;
rwsdl:binding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)>;
rwsdl:address <http://greath.example.com/2004/reservation> .
_:L9C14
a rwsdl:QName .
rwsdl:localName "invalidDataError";
rwsdl:namespace "http://greath.example.com/2004/schemas/resSvc";
_:L22C18
a rwsdl:QName .
rwsdl:localName "checkAvailability";
rwsdl:namespace "http://greath.example.com/2004/schemas/resSvc";
_:L32C18
a rwsdl:QName .
rwsdl:localName "checkAvailabilityResponse";
rwsdl:namespace "http://greath.example.com/2004/schemas/resSvc";
4. Differences from
the WSDL Component Model (Informative)
WSDL defines a component model which
consists of components, component properties and sets of
components. This document supplies an ontology (i.e., a set of
classes, properties, datatypes, and distinguished
individuals) for representing WSDL
data. This ontology contains axioms which express some of
the constraints the WSDL specification
imposes on legal sets of WSDL components whether indirectly (via
the XML Schema constraints on the infoset which canonically encodes
WSDL component models) or directly (via the natural language of the
WSDL specs, or the corresponding Z formalizations of that
language).
RDF, RDFS, and OWL are all less (and
differently) expressive than the subset of Z used to formalize the
WSDL specification, and are designed for different purposes. In a
nutshell, RDF, RDFS, and OWL are relatively small fragments of
first order logic, whereas Z encompasses all of first order logic
plus set theory. Z supports validation of
component models, that is, the acceptance or rejection of component
models. This includes type checking, consistency checking, and the
verification of integrity constraints. The same reasoning applies current set of Semantic Web languages focus on inference
and integration of information. To take a simple example, if a Z
checkable representation of an Interface component lacks a {name}
component property, a Z based validator will complain that that
representation is ill formed (given the WSDL specification). An OWL
reasoner encountering it will, all other things being equal,
conclude that there is such a property,
even though the reasoner has not seen it yet. In general, Semantic
Web based descriptions of Web services using the WSDL conceptual
framework tend to be looser than
what the schema WSDL specification prescribes.
This difference effectively introduces
two classes of documents included that use the
ontology from this document:
- RDF documents resulting from translating
valid WSDL documents,
- arbitrary RDF documents written using
the WSDL ontology.
This document focuses on the mapping from
valid WSDL component models, and imported this
section in particular talks about
differences between a valid component model and its RDF
representation.
However, we must note that arbitrary RDF,
RDFS, or OWL documents that use the WSDL ontology may describe
component models that are incomplete or even illegal. For example,
from the point of view of arbitrary RDF documents that use the WSDL
ontology, interfaces don't need to belong to any Description.
Therefore, the subsections also contain notes about arbitrary RDF documents
detailing further differences that an
application consuming WSDL RDF data can encounter in documents that
are not the direct result of mapping a valid WSDL document into its
RDF form. The last subsection ( section 4.5
) then describes those constraints
unenforced by the WSDL, that do not fit in any other subsection
above it.
4.1 Component
naming
In the RDF representation, all WSDL
components are identified with their respective component
designators (see [ WSDL 2.0 Core Language ] appendix C
IRI-References for WSDL 2.0
Components ), which are URIs
generally constructed from the name and namespace of the component
and from its parent component hierarchy. The original names and
namespaces are not explicitly modeled in the RDF representation,
which intends to convey the semantic meaning of the WSDL component,
not the WSDL serialization details.
In some situations we can see the RDF
representation to be used as an exchange syntax for WSDL.
All While it's
not an intended use, it is possible that in some systems the XML
syntax will be lost or inaccessibly hidden in several layers of
processing software. Such an application that only receives the RDF
form of WSDL can still need to reconstruct the original component
names, for example if it uses an API that identifies WSDL
operations by their parent interface's QName and the operation
name.
The component designators put the names
of the components in the fragment identifier part of the resulting
URIs. On the Web (see [ Web Architecture ]),
the interpretation of fragment identifiers is defined by the MIME
media type of the representation of the resource identified by the
URI without the fragment identifier. In our particular case, we
expect that the namespace URI identifies an
application/wsdl+xml
document so that the constructed component
designator fragment identifiers can have their intended meaning. An
application working with the RDF representation of WSDL can
reconstruct the names of the components by reversing the process
that resulted in the component designator, for example for a
URI http://example.com/service#wsdl.interfaceOperation(TicketInterface/BookTicket)
we could reconstruct that the name of the
interface is "TicketInterface" in the namespace
http://example.com/service and that the operation is named "BookTicket".
Such decomposition is only valid, though,
if the URI http://example.com/service identifies a document of MIME media type
application/wsdl+xml
,as explained above. Checking the MIME media
type of every resource identified by a URI in an RDF graph could be
prohibitively slow for some applications, therefore it may be
practical (albeit not entirely correct) simply to assume the
correct media type and deconstruct the component names without the
preceding media type check.
Note about arbitrary RDF
documents: in general, it is
possible to assert about any resource (identified by any kind of
URI) that it is, for example, a WSDL operation, and if an
application tries to deconstruct that URI according to WSDL
component designator specification, it may find that the URI
doesn't conform to the syntax (e.g. http://example.com/service/operation)
or, by accident or malice, it does conform
to the syntax but doesn't contain the correct data (e.g.
http://example.com/service#wsdl.interface(TicketInterface)
that is marked to be a WSDL operation, not
an interface as it would seem).
4.2 Documents, imports and
includes
In the XML syntax for WSDL, documents can
be included and imported, allowing for modularization while keeping
the ability to validate that a WSDL document (plus all the includes
and imports) doesn't use any unknown components. Such
modularization is lost when the WSDL files are parsed into a
component model, therefore a straigtforward transformation of such
a component model into RDF will result in a single RDF
document.
As one exception, all references
to element declarations and type definitions from XML Schema are done deleted text: by
QName in the RDF representation by
QName and we expect the applications processing this
representation to have means of locating the appropriate
descriptions for these QNames. We do not model XML Schema (or any
other) type and element descriptions in this ontology.
Note about arbitrary RDF
documents: RDF data can be split
into any number of pieces, which can be put together by the
processing application as appropriate. If a piece of WSDL/RDF
description uses an unknown component (e.g. an interface described
in one document may extend other interfaces, not described in this
document), the application may, if necessary, attempt to locate the
description of the unknown component, for example using its
identifier IRI. Note that RDF does not provide a standard generic
way of including external data, so any inclusion is
application-specific.
Additionally, a single RDF document may
also contain multiple unrelated Descriptions, that is, it may be an
aggregation of many unrelated WSDL documents, and this may have
unexpected results if the aggregated WSDL data contains conflicts,
i.e. different definitions of components with the same name;
especially when dealing with different versions of descriptions of
the same entities.
: Additionally, certain components in WSDL are only pointers, they
only have a single literal property that points to an external
thing. For example, the feature component only carries the URI of
the feature, and the HTTP Header component only carries an element
QName. While these components can contain documentation and
extensions in WSDL2, WSDL, we chose to represent these components as
direct links from the parent component to the target feature or the
element QName, as the indirection seems to add very little value.
3.4
4.4 Representing properties with
classes
In certain cases the RDF mapping introduces classes where the
WSDL 2 component model has a property with a limited number of
values. For instance, instead of having a direction property on
message and fault references, with the values either "in" or "out",
we introduce two classes, InputMessage and
OutputMessage , and the direction of a particular
message or fault reference is then indicated by belonging to either
of these classes. Similarly, binding types are classes and the type
of a particular binding is indicated by its belonging to that
class; we predefine the two classes for the two bindings that are
part of WSDL 2. Finally, the operation safety property is
represented with the class SafeInteraction , and safe
operations are instances of this class.
On a similar note, in the case of features, the flag that a
feature is required is not modeled as a property of the feature
component, required features are instead pointed to using the RDF
property requiresFeature , whereas optional features
are pointed to using the property offersFeature .
4.5 Other WSDL
restrictions not enforced by the ontology
As already mentioned, the
validation-oriented WSDL specification and especially its Z
formalization capture a number of restrictions and limitations that
are not expressed in the RDF ontology. None of these restrictions
or limitations can be violated when a valid WSDL document is mapped
into its RDF form. When the RDF data is directly manipulated, for
example merged with other RDF data (for example other WSDL
documents mapped into RDF), or when new data is created that uses
the WSDL ontology, further significant WSDL constraints might be
violated:
- In WSDL, components of different types
do not overlap, e.g. an interface is always a different thing from
a binding (even if they have the same name), but an arbitrary RDF
document can assert that one resource is both an interface and a
binding.
- In WSDL, a Description cannot directly
contain interface operations or endpoints, for example; an endpoint
is always in a service and interface operations are always in
interfaces. The ontology does not enforce these restrictions so an
arbitrary RDF file that is consistent with the ontology may
describe a broken hierarchy of components.
5.
References
- [OWL]
- OWL Web Ontology Language Reference
,Mike Dean,Guus Schreiber, Editors. W3C
Recommendation 10 February 2004 . Available at
http://www.w3.org/TR/owl-ref/
- [RDF]
- Resource Description Framework (RDF): Concepts and
Abstract Syntax ,Graham
Klyne, Jeremy J. Carroll, Editors. W3C Recommendation, 10 February
2004. Available at http://www.w3.org/TR/rdf-concepts/
- [Web Architecture]
- Architecture of the World Wide Web, Volume
One ,Ian Jacobs, Norman
Walsh, Editors. W3C Recommendation, 15 December, 2004. Available at
http://www.w3.org/TR/2004/REC-webarch-20041215/ .
- [WSDL 2.0 Core
Language]
- Web Services Description Language (WSDL) Version 2.0
Part 1: Core Language ,R.
Chinnici, M. Gudgin, J-J. Moreau, S. Weerawarana, Editors. World
Wide Web Consortium, 27 March 2006. This version of the "Web
Services Description Language (WSDL) Version 2.0 Part 1: Core
Language" Specification is available is available at
http://www.w3.org/TR/2006/CR-wsdl20-20060327. The latest version
of "Web Services Description Language (WSDL) Version 2.0 Part 1:
Core Language" is available at
http://www.w3.org/TR/wsdl20.
- [WSDL 2.0
Adjuncts]
-
Web Services Description Language (WSDL) Version 2.0 Part 2:
Adjuncts , R. Chinnici, H.
Haas, A. Lewis, J-J. Moreau, D. Orchard, S. Weerawarana, Editors.
World Wide Web Consortium, 27 March 2006. This version of the "Web
Services Description Language (WSDL) Version 2.0 Part 2: Adjuncts"
Specification is available at
http://www.w3.org/TR/2006/CR-wsdl20-adjuncts-20060327. The
latest version of "Web Services Description Language
(WSDL) Version 2.0 Part 2: Adjuncts" is available at
http://www.w3.org/TR/wsdl20-adjuncts.
appendix
Appendix A: The OWL Ontology Source
Note that the deleted text: owl
ontology source </h2>
is also available in a separate RDF file
.
deleted text:
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:wsdl="http://www.w3.org/2005/10/wsdl-rdf#"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
xml:base="http://www.w3.org/2005/10/wsdl-rdf">
<!-- todo modularize into many more namespaces -->
<!-- the following are notes on the deviations this model has from the WSDL2
component model:
direction - msg ref or fault ref instance of inputmessage or outputmessage
feature is a direct reference, property is indirect
binding types as classes (or subclasses of binding)
for us, MEPs are one individual of MessageExchangePattern and a number of
individuals of MessageLabel
fault propagation rules in MEPs are modeled as subclasses of MEP
message labels are qualified with mep name and so are different for each MEP
maybe we could model safety as general-purpose class of things safe, now it's
a class of safe operations
documentation, extensions not handled on HTTP header - maybe a
mapping using blank node and rdf:value? headers also don't use the component
designators as they go directly to the qname
-->
<!-- todo maybe rename properties to verbs and adjectives? -->
<owl:Ontology rdf:about="">
</owl:Ontology>
<owl:Class rdf:about="#Binding">
</owl:Class>
<owl:Class rdf:about="#BindingFault">
</owl:Class>
<owl:Class rdf:about="#BindingFaultReference">
</owl:Class>
<owl:Class rdf:about="#BindingMessageReference">
</owl:Class>
<owl:Class rdf:about="#BindingOperation">
<rdfs:comment>The type of a binding is indicated with rdf:type</rdfs:comment>
</owl:Class>
<owl:Class rdf:about="#Description">
</owl:Class>
<owl:Class rdf:about="#Endpoint">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#address"/>
<owl:maxCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#Feature">
</owl:Class>
<owl:Class rdf:about="#Interface">
<rdfs:label>WDSL Interface</rdfs:label>
</owl:Class>
<owl:Class rdf:about="#InterfaceFault">
</owl:Class>
<owl:Class rdf:about="#InterfaceFaultReference">
</owl:Class>
<owl:Class rdf:about="#InterfaceMessageReference">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#messageContentModel"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#InputMessage">
<rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment>
<owl:disjointWith rdf:resource="#OutputMessage"/>
</owl:Class>
<owl:Class rdf:about="#OutputMessage">
<rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment>
</owl:Class>
<owl:Class rdf:about="#InterfaceOperation">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#messageExchangePattern"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#PropertyValue">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#propertyValue"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#Property">
</owl:Class>
<owl:Class rdf:about="#Service">
</owl:Class>
<owl:Class rdf:about="#MessageExchangePattern">
</owl:Class>
<owl:Class rdf:about="#MessageLabel">
</owl:Class>
<owl:ObjectProperty rdf:about="#definesMessageLabel">
<rdfs:domain rdf:resource="#MessageExchangePattern"/>
<rdfs:range rdf:resource="#MessageLabel"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#address">
<rdfs:domain rdf:resource="#Endpoint"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#binding">
<rdfs:range rdf:resource="#Binding"/>
<rdfs:comment>To be used for pointing to a Binding, for example from Description or Endpoint</rdfs:comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#bindingFault">
<rdfs:range rdf:resource="#BindingFault"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#bindingOperation">
<rdfs:range rdf:resource="#BindingOperation"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#bindingMessageReference">
<rdfs:range rdf:resource="#BindingMessageReference"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#bindingFaultReference">
<rdfs:range rdf:resource="#BindingFaultReference"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#typeDefinition">
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#elementDeclaration">
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#endpoint">
<rdfs:range rdf:resource="#Endpoint"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#extensionOf">
<rdfs:range rdf:resource="#Interface"/>
<rdfs:domain rdf:resource="#Interface"/>
</owl:ObjectProperty>
<owl:Class rdf:about="#QName">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#localName"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#namespace"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:DatatypeProperty rdf:about="#localName">
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#NCName"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="#namespace">
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#anyURI"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="#offersFeature">
<rdfs:range rdf:resource="#Feature"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#requiresFeature">
<rdfs:range rdf:resource="#Feature"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#interface">
<rdfs:range rdf:resource="#Interface"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#interfaceFault">
<rdfs:range rdf:resource="#InterfaceFault"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#interfaceFaultReference">
<rdfs:range rdf:resource="#InterfaceFaultReference"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#interfaceMessageReference">
<rdfs:range rdf:resource="#InterfaceMessageReference"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#operationStyle">
<rdfs:domain rdf:resource="#InterfaceOperation"/>
<rdfs:range rdf:resource="#OperationStyle"/>
<rdfs:comment>
points to one style this operation conforms to (can be used multiple times
to point to multiple styles)
</rdfs:comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#interfaceOperation">
<rdfs:range rdf:resource="#InterfaceOperation"/>
<rdfs:comment>
can be used on interface to link to an operation and on a binding
operation to link to the interface operation that is being bound
</rdfs:comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#messageContentModel">
<rdfs:range rdf:resource="#MessageContentModel"/>
</owl:ObjectProperty>
<owl:Class rdf:about="#MessageContentModel">
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#AnyContent"/>
<owl:Thing rdf:about="#NoContent"/>
<owl:Thing rdf:about="#ElementContent"/>
<owl:Thing rdf:about="#OtherContent"/>
<wsdl:MessageContentModel rdf:about="#AnyContent"/>
<wsdl:MessageContentModel rdf:about="#NoContent"/>
<wsdl:MessageContentModel rdf:about="#ElementContent"/>
<wsdl:MessageContentModel rdf:about="#OtherContent"/>
</owl:oneOf>
</owl:Class>
<owl:ObjectProperty rdf:about="#messageExchangePattern">
<rdfs:range rdf:resource="#MessageExchangePattern"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#messageLabel">
<rdfs:range rdf:resource="#MessageLabel"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#propertyValue">
<rdfs:range rdf:resource="#PropertyValue"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#property">
<rdfs:range rdf:resource="#Property"/>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="#propertyActualValue">
<rdfs:domain rdf:resource="#PropertyValue"/>
<rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="#propertyValueType">
<rdfs:domain rdf:resource="#PropertyValue"/>
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#service">
<rdfs:range rdf:resource="#Service"/>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="#documentation">
<rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/>
</owl:DatatypeProperty>
<!-- todo - can we combine extensionElement property with extensionAttribute
into an "extension" property? Problem is the first is datatype and the second
is object property - is that a real problem? -->
<owl:DatatypeProperty rdf:about="#extensionElement">
<rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="#extensionAttribute">
<rdfs:range rdf:resource="#ExtensionAttribute"/>
</owl:ObjectProperty>
<owl:Class rdf:about="#ExtensionAttribute">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#attributeName"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:comment>
Represents an extension attribute with a name and a value. The value
should be a literal. This should only be used for extension attributes
that aren't understood by the generator of the RDF model, otherwise the
extension should define how the attribute shows in the RDF model.
</rdfs:comment>
</owl:Class>
<owl:ObjectProperty rdf:about="#attributeName">
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<!-- part 2: message exchange patterns -->
<owl:Class rdf:about="#NoFaults">
<rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
<owl:disjointWith rdf:resource="#FaultReplacesMessage"/>
<owl:disjointWith rdf:resource="#MessageTriggersFault"/>
</owl:Class>
<owl:Class rdf:about="#FaultReplacesMessage">
<rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
<owl:disjointWith rdf:resource="#MessageTriggersFault"/>
</owl:Class>
<owl:Class rdf:about="#MessageTriggersFault">
<rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
</owl:Class>
<wsdl:NoFaults rdf:about="http://www.w3.org/2005/08/wsdl/in-only">
<wsdl:NoFaults rdf:about="http://www.w3.org/2006/01/wsdl/in-only">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/in-only#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/in-only#In"/>
</wsdl:definesMessageLabel>
</wsdl:NoFaults>
<wsdl:NoFaults rdf:about="http://www.w3.org/2005/08/wsdl/out-only">
<wsdl:NoFaults rdf:about="http://www.w3.org/2006/01/wsdl/out-only">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/out-only#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/out-only#Out"/>
</wsdl:definesMessageLabel>
</wsdl:NoFaults>
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2005/08/wsdl/robust-in-only">
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/robust-in-only#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only#In"/>
</wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2005/08/wsdl/in-opt-out">
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/in-opt-out#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#In"/>
</wsdl:definesMessageLabel>
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/in-opt-out#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#Out"/>
</wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2005/08/wsdl/robust-out-only">
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/robust-out-only#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only#Out"/>
</wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2005/08/wsdl/out-opt-in">
<wsdl:MessageTriggersFault rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/out-opt-in#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#Out"/>
</wsdl:definesMessageLabel>
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/out-opt-in#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#In"/>
</wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>
<wsdl:FaultReplacesMessage rdf:about="http://www.w3.org/2005/08/wsdl/in-out">
<wsdl:FaultReplacesMessage rdf:about="http://www.w3.org/2006/01/wsdl/in-out">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/in-out#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/in-out#In"/>
</wsdl:definesMessageLabel>
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/in-out#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/in-out#Out"/>
</wsdl:definesMessageLabel>
</wsdl:FaultReplacesMessage>
<wsdl:FaultReplacesMessage rdf:about="http://www.w3.org/2005/08/wsdl/out-in">
<wsdl:FaultReplacesMessage rdf:about="http://www.w3.org/2006/01/wsdl/out-in">
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/out-in#Out"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/out-in#Out"/>
</wsdl:definesMessageLabel>
<wsdl:definesMessageLabel>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2005/08/wsdl/out-in#In"/>
<wsdl:MessageLabel rdf:about="http://www.w3.org/2006/01/wsdl/out-in#In"/>
</wsdl:definesMessageLabel>
</wsdl:FaultReplacesMessage>
<!-- part 2: safety -->
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl-extensions#SafeInteraction">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl-extensions#SafeInteraction">
<rdfs:subClassOf rdf:resource="#InterfaceOperation" />
<rdfs:comment>
Class of all operations that are asserted to be safe interactions as defined in
Web Architecture at W3C.
</rdfs:comment>
</owl:Class>
<!-- part 2: operation styles -->
<wsdl:OperationStyle rdf:about="http://www.w3.org/2005/08/wsdl/style/rpc">
<wsdl:OperationStyle rdf:about="http://www.w3.org/2006/01/wsdl/style/rpc">
<rdfs:comment>RPC operation style</rdfs:comment>
</wsdl:OperationStyle>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/rpc#signature">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/rpc#signature">
<rdfs:domain rdf:resource="#InterfaceOperation"/>
<rdfs:range rdf:resource="http://www.w3.org/2005/08/wsdl/rpc#signatureType"/>
<rdfs:range rdf:resource="http://www.w3.org/2006/01/wsdl/rpc#signatureType"/>
<rdfs:comment>todo - can we use the above URI for the datatype of this property?</rdfs:comment>
</owl:DatatypeProperty>
<wsdl:OperationStyle rdf:about="http://www.w3.org/2005/08/wsdl/style/iri">
<wsdl:OperationStyle rdf:about="http://www.w3.org/2006/01/wsdl/style/iri">
<rdfs:comment>IRI operation style</rdfs:comment>
</wsdl:OperationStyle>
<wsdl:OperationStyle rdf:about="http://www.w3.org/2005/08/wsdl/style/multipart">
<wsdl:OperationStyle rdf:about="http://www.w3.org/2006/01/wsdl/style/multipart">
<rdfs:comment>multipart operation style</rdfs:comment>
</wsdl:OperationStyle>
<!-- part 2: bindings -->
<!-- SOAP binding -->
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/soap">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/soap">
<rdfs:comment>WSDL 2 SOAP binding</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/2005/08/wsdl/soap#version"/>
<owl:onProperty rdf:resource="http://www.w3.org/2006/01/wsdl/soap#version"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/2005/08/wsdl/soap#protocol"/>
<owl:onProperty rdf:resource="http://www.w3.org/2006/01/wsdl/soap#protocol"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#version">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#version">
<rdfs:comment>
indicates what version of SOAP is used by the binding, usually "1.2"
todo - using string is fairly ugly, but can we invent URIs?
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#protocol">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#protocol">
<rdfs:comment>
indicates the underlying protocol used by a binding
todo - protocol class and the known instances?
</rdfs:comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#faultCode">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#faultCode">
<rdfs:comment>
indicates the fault code of a binding fault
</rdfs:comment>
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#faultSubcode">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#faultSubcode">
<rdfs:comment>
indicates a fault subcode of a binding fault; there can be multiple subcodes
todo - the list of subcodes is ordered in SOAP 1.2
</rdfs:comment>
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#soapMEP">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#soapMEP">
<rdfs:comment>
indicates the SOAP MEP this binding operation uses
</rdfs:comment>
<rdfs:range rdf:resource="#SOAPMessageExchangePattern"/>
<rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#defaultSoapMEP">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#defaultSoapMEP">
<rdfs:comment>
indicates the default SOAP MEP this binding's operations use
</rdfs:comment>
<rdfs:range rdf:resource="#SOAPMessageExchangePattern"/>
<rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</owl:ObjectProperty>
<owl:Class rdf:about="#SOAPMessageExchangePattern">
<owl:Class rdf:about="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs">
<rdfs:comment>
todo - the URI of this class could be SOAP-1.2-specific, not WSDL2-specific
</rdfs:comment>
</owl:Class>
<wsdl:SOAPMessageExchangePattern
rdf:about="http://www.w3.org/2003/05/soap/mep/request-response/"/>
<rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/request-response/">
<rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</rdf:Description>
<wsdl:SOAPMessageExchangePattern
rdf:about="http://www.w3.org/2003/05/soap/mep/soap-response/"/>
<rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/soap-response/">
<rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</rdf:Description>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#action">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#action">
<rdfs:comment>
indicates the SOAP action this binding operation uses
</rdfs:comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#offersSOAPModule">
<rdfs:range rdf:resource="http://www.w3.org/2005/08/wsdl/soap#SOAPModule"/>
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#offersSOAPModule">
<rdfs:range rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#requiresSOAPModule">
<rdfs:range rdf:resource="http://www.w3.org/2005/08/wsdl/soap#SOAPModule"/>
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#requiresSOAPModule">
<rdfs:range rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>
</owl:ObjectProperty>
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/soap#SOAPModule">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPModule">
<rdfs:comment>
a SOAP module; a WSDL 2 SOAP binding (and subcomponents) may use or
require any number of modules
</rdfs:comment>
</owl:Class>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/soap#header">
<rdfs:range rdf:resource="http://www.w3.org/2005/08/wsdl/soap#SOAPHeader"/>
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/soap#header">
<rdfs:range rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeader"/>
</owl:ObjectProperty>
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/soap#SOAPHeader">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPHeader">
<rdfs:comment>
a SOAP header
</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#elementDeclaration"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/soap#MustUnderstandSOAPHeader">
<rdfs:subClassOf rdf:resource="http://www.w3.org/2005/08/wsdl/soap#SOAPHeader" />
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/soap#MustUnderstandSOAPHeader">
<rdfs:subClassOf rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeader" />
<rdfs:comment>
a SOAP header that must be marked as mustUnderstand by the sender
</rdfs:comment>
</owl:Class>
<!-- HTTP binding -->
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/http">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/http">
<rdfs:comment>WSDL 2 HTTP binding</rdfs:comment>
deleted text:
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/2005/08/wsdl/http#version"/>
<owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#version">
<rdfs:comment>
indicates what version of SOAP is used by the binding, usually "1.1"
todo - using string is fairly ugly, but can we invent URIs?
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#location">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#location">
<rdfs:comment>
defines the location for an operation, relative to the address of the
service; this is the only URI-valued property modeled as datatype
property because the URI is not meant as pointer to a resource
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#anyURI"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#defaultMethod">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultMethod">
<rdfs:comment>
declares the default HTTP method used by this binding's operations
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#method">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#method">
<rdfs:comment>
declares the HTTP method used by this operation
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#inputSerialization">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#inputSerialization">
<rdfs:comment>
declares the media type of the input message of an operation
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#outputSerialization">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#outputSerialization">
<rdfs:comment>
declares the media type of the output message of an operation
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#faultSerialization">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#faultSerialization">
<rdfs:comment>
declares the media type of the fault messages of an operation
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#defaultQueryParameterSeparator">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultQueryParameterSeparator">
<rdfs:comment>
declares the default character to be used as query parameter separator by this binding's operations
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#queryParameterSeparator">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#queryParameterSeparator">
<rdfs:comment>
declares the character to be used as query parameter separator by an operation
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#header">
<owl:ObjectProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#header">
<rdfs:range rdf:resource="#QName"/>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#errorCode">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#errorCode">
<rdfs:comment>
declares the error status code that a fault will return
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#int"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#errorReason">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#errorReason">
<rdfs:comment>
declares the error reason phrase that a fault will return
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#defaultTransferCoding">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultTransferCoding">
<rdfs:comment>
declares the default transfer coding to be used by this binding's operation messages
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#transferCoding">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#transferCoding">
<rdfs:comment>
declares the transfer coding to be used by operation messages
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:Class rdf:about="http://www.w3.org/2005/08/wsdl/http#HTTPBindingWithCookies">
<owl:Class rdf:about="http://www.w3.org/2006/01/wsdl/http#HTTPBindingWithCookies">
<rdfs:comment>WSDL 2 HTTP binding with cookies</rdfs:comment>
<rdfs:subClassOf rdf:resource="http://www.w3.org/2005/08/wsdl/http"/>
<rdfs:subClassOf rdf:resource="http://www.w3.org/2006/01/wsdl/http"/>
</owl:Class>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#authenticationType">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationType">
<rdfs:comment>
declares the authentication type used by an endpoint, by default "none"
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:DatatypeProperty rdf:about="http://www.w3.org/2005/08/wsdl/http#authenticationRealm">
<owl:DatatypeProperty rdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationRealm">
<rdfs:comment>
declares the authentication realm used by an endpoint
</rdfs:comment>
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<!-- todo binding defaults are necessary for interfaceless bindings, but they
aren't currently in the component model - they are modeled here tho, in
anticipation that my LC comment gets accepted -->
</rdf:RDF>
appendix
Appendix B: mapping wsdl files to
rdf
deleted text: <p> todo: mapping there, not really back,
certainly not roundtrip </p> <p id='todo'> todo, plus
references </p> </div> </body>
</html>