Saturday, January 18, 2014

WSDL

W3C
http://www.w3.org/TR/2004/WD-wsdl20-extensions-20040803/

Web Services Description Language (WSDL) Version 2.0 Part 2: Predefined Extensions

W3C Working Draft 3 August 2004

This version:
http://www.w3.org/TR/2004/WD-wsdl20-extensions-20040803
Latest version:
http://www.w3.org/TR/wsdl20-extensions
Previous versions:
http://www.w3.org/TR/2004/WD-wsdl20-patterns-20040326
Editors:
Martin Gudgin, Microsoft
Amy Lewis, TIBCO
Jeffrey Schlimmer, Microsoft
This document is also available in these non-normative formats: postscriptPDFXML, and plain text.

Abstract

This document describes extensions for the Web Services Description Language (WSDL) Version 2.0 . These extensions include Message Exchange Patterns (MEPs), features, SOAP modules, and bindings of features. The Working Group has discussed and approved these extensions, and recommends their use with the Web Services Description Language (WSDL).

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is a W3C Last Call Working Draft. If the feedback is positive, the Working Group plans to submit this specification for consideration as a W3C Candidate Recommendation. Comments on this document are invited and are to be sent to the public public-ws-desc-comments@w3.org mailing list (public archive). Comments can be sent until 4 October 2004.
Three formal objections from Working Group participants have been received against portions of the WSDL 2.0 specification. Feedback is specifically encouraged on these topics:
diff-marked version against the previous version of this document is available. For a detailed list of changes since the last publication of this document, please refer to appendix B. Change Log. Issues about this document are documented in the last call issues list maintained by the Working Group.
This document has been produced as part of the W3C Web Services Activity. The authors of this document are the Web Services Description Working Group members.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document has been produced under the 24 January 2002 Current Patent Practice as amended by the W3C Patent Policy Transition Procedure. Patent disclosures relevant to this specification may be found on the Working Group's patent disclosure page. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) with respect to this specification should disclose the information in accordance with section 6 of the W3C Patent Policy.


Table of Contents

1. Introduction
    1.1 Notational Conventions
2. Predefined Message Exchange Patterns
    2.1 Fault Propagation Rules
        2.1.1 Fault Replaces Message
        2.1.2 Message Triggers Fault
        2.1.3 No Faults
    2.2 Message Exchange Patterns
        2.2.1 In-Only
        2.2.2 Robust In-Only
        2.2.3 In-Out
        2.2.4 In-Optional-Out
        2.2.5 Out-Only
        2.2.6 Robust Out-Only
        2.2.7 Out-In
        2.2.8 Out-Optional-In
3. Predefined Features
    3.1 Application Data Feature
        3.1.1 Name
        3.1.2 Operation
        3.1.3 AD/data Property
        3.1.4 Description
        3.1.5 The ad:mustUnderstand Attribute
    3.2 Application Data Module
        3.2.1 Features Implemented
        3.2.2 Operation
    3.3 Application data serialization as HTTP headers
        3.3.1 Name
        3.3.2 Features Implemented
        3.3.3 Operation
4. References
    4.1 Normative References
    4.2 Informative References

Appendices

A. Acknowledgements (Non-Normative)
B. Change Log (Non-Normative)
    B.1 Changes

1. Introduction

Web Services Description Language provides a number of opportunities to extend the syntax and component model, as mandated by the needs of an application. This document defines and describes a number of these extensions, particularly message exchange patterns and features.

1.1 Notational Conventions

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

2. Predefined Message Exchange Patterns

Web Services Description Language (WSDL) message exchange patterns (hereafter simply 'patterns') define the sequence and cardinality of abstract messages listed in an operation. Message exchange patterns also define which other nodes send messages to, and receive messages from, the service implementing the operation. WSDL message exchange patterns describe the interaction at the abstract (interface) level, which may be distinct from the pattern used by the underlying protocol binding (e.g. SOAP Message Exchange Patterns).
By design, WSDL message exchange patterns abstract out specific message types. Patterns identify placeholders for messages, and placeholders are associated with specific message types by the operation using the pattern.
Unless explicitly stated otherwise, WSDL message exchange patterns also abstract out binding-specific information like timing between messages, whether the pattern is synchronous or asynchronous, and whether the message are sent over a single or multiple channels.
Like interfaces and operations, WSDL message exchange patterns do not exhaustively describe the set of messages exchanged between a service and other nodes; by some prior agreement, another node and/or the service may send other messages (to each other or to other nodes) that are not described by the pattern. For instance, even though a pattern may define a single message sent from a service to one other node, the Web Service may multicast that message to other nodes.
To maximize reuse, WSDL message exchange patterns identify a minimal contract between other parties and Web Services, and contain only information that is relevant to both the Web Service and another party.
This specification defines several message exchange patterns for use with WSDL Version 2.0 Part 1: Core Language [WSDL 2.0 Core Language].

2.1 Fault Propagation Rules

WSDL patterns specify their fault propagation model using standard rulesets to indicate where faults may occur. The most common patterns for fault propagation are defined here, and referenced by patterns later in the document.
Generation of a fault, regardless of ruleset, terminates the exchange.

2.1.1 Fault Replaces Message

Any message after the first in the pattern MAY be replaced with a fault message, which MUST have identical cardinality and direction. The fault message MUST be delivered to the same target node as the message it replaces. If there is no path to this node, the fault MUST be discarded.

2.1.2 Message Triggers Fault

Any message, including the first, MAY trigger a fault message in response. Each recipient MAY propagate a fault message, and MUST propagate no more than one fault for each triggering message. Each fault message has direction the reverse of its triggering message. The fault message MUST be delivered to the originator of the message which triggered it. If there is no path to this node, the fault MUST be discarded.

2.1.3 No Faults

No faults may be propagated.

2.2 Message Exchange Patterns

WSDL patterns are described in terms of the WSDL component model, specifically the Message Label and Fault Reference components.

2.2.1 In-Only

This pattern consists of exactly one message as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'In' and {direction} is 'in'
    • received from some node N
This pattern uses the rule 2.1.3 No Faults.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/in-only'.

2.2.2 Robust In-Only

This pattern consists of exactly one message as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'In' and {direction} is 'in'
    • received from some node N
This pattern uses the rule 2.1.2 Message Triggers Fault.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/robust-in-only'.

2.2.3 In-Out

This pattern consists of exactly two messages, in order, as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'In' and {direction} is 'in'
    • received from some node N
  2. A message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to node N
This pattern uses the rule 2.1.1 Fault Replaces Message.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/in-out'.

2.2.4 In-Optional-Out

This pattern consists of one or two messages, in order, as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'In' and {direction} is 'in'
    • received from some node N
  2. An optional message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to node N
This pattern uses the rule 2.1.2 Message Triggers Fault.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/in-opt-out'.

2.2.5 Out-Only

This pattern consists of exactly one message as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to some node N
This pattern uses the rule 2.1.3 No Faults.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/out-only'.

2.2.6 Robust Out-Only

This pattern consists of exactly one message as follows:
  1. message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to some node N
This pattern uses the rule 2.1.2 Message Triggers Fault.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/robust-out-only'.

2.2.7 Out-In

This pattern consists of exactly two messages, in order, as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to some node N
  2. A message:
    • indicated by a Message Label component whose {message label} is 'In' and {direction} is 'in'
    • sent from node N
This pattern uses the rule 2.1.1 Fault Replaces Message.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/out-in'.

2.2.8 Out-Optional-In

This pattern consists of one or two messages, in order, as follows:
  1. A message:
    • indicated by a Message Label component whose {message label} is 'Out' and {direction} is 'out'
    • sent to some node N
  2. An optional message:
    • indicated by a MessageLabel component whose {message label} is 'In' and {direction} is 'in'
    • sent from node N
This pattern uses the rule 2.1.2 Message Triggers Fault.
An operation using this message exchange pattern has a {pattern} property with the value 'http://www.w3.org/2004/08/wsdl/out-opt-in'.

3. Predefined Features

Web Services Description Language (WSDL) features (hereafter 'features') define pieces of extended functionality which typically affect message exchanges. Examples may include "reliability", "security", or "correlation", among others. Features may be self-contained, or may be abstract, and thus expressed via bindings or SOAP modules. These components may expose settable properties, named variables which affect the behavior of one or more features, bindings or SOAP modules.
Features may change the behavior described for other components. In particular, note that a feature (or any other extension) may change the semantics of a message exchange pattern in some fashion, such as nominating an address for the delivery of faults, etc.
The Web Services Description Working Group provides the following predefined features and SOAP modules for two reasons - first, we encourage implementors to support these features as we believe they offer important functionality. Second, these specifications act as a model of how to write feature/module specs. Some further (SOAP-specific) examples can be found in the SOAP 1.2 spec, part 2.

3.1 Application Data Feature

3.1.1 Name

This feature is identified with the URI 'http://www.w3.org/2004/08/wsdl/feature/AD'

3.1.2 Operation

This feature exists in order to enable the description of application-defined additional data declarations outside of the normal data channel (e.g. the SOAP body). The senders takes the value of the property 'http://www.w3.org/2004/08/wsdl/feature/AD/data', which is defined below, and passes it to the receiver in a manner to be defined by the particular bindings/modules implementing this specification.

3.1.3 AD/data Property

This property is identified with the URI 'http://www.w3.org/2004/08/wsdl/feature/AD/data'.

3.1.4 Description

The data property consists of a sequence of elements, each of which represents an individual piece of application data. Implementations of this feature must ensure that the runtime value of this property is correctly transferred from the sender to the receiver.
Here is an example of using the data property in a WSDL:
<types>
 <schema targetNamespace="http://example.com/ws/wsdl20/my-ws"
         xmlns:xs="http://www.w3.org/2001/XMLSchema"
         xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:ad="http://www.w3.org/2004/08/wsdl/feature/AD">
  <!-- Define the data type we'll use later -->
  <complexType name="myDataType">
   <sequence>

    <!-- These elements are our data -->
    <element name="isGoldClubMember" type="xs:boolean"
             ad:mustUnderstand="true" />

    <element name="promotionalCode"
             type="xs:string"
             minOccurs="0"/>

   </sequence>
  </complexType>
 </schema>
</types>
<interface name="customerService">
 <operation name="reserveCar">
  <input element="myNS:reserveCarRequest">
   <property uri="http://www.w3.org/2004/08/wsdl/feature/AD/data">
    <constraint xmlns:foo="http://example.com/">
     foo:myDataType
    </constraint>
   </property>
  </input>
 </operation>
</interface>
This example defines two pieces of application data, and associates them with the input message of the "reserveCar" operation. Notice that the "promotionalCode" element is optional (minOccurs="0").

3.1.5 The ad:mustUnderstand Attribute

You may choose to decorate your application data element declarations with an attribute with the namespace 'http://www.w3.org/2004/08/wsdl/feature/AD' and the local name "mustUnderstand". This indicates at the abstract level that the particular element thus decorated is mandatory, and implementations of this feature which support expression of mandatory data (i.e. the Application Data SOAP Module, see 3.2 Application Data Module) should mark them as mandatory in an appropriate way.

3.2 Application Data Module

This module is identified with the URI 'http://www.w3.org/2004/08/wsdl/module/AD'

3.2.1 Features Implemented

This module implements the feature 'http://www.w3.org/2004/08/wsdl/feature/AD' (see 3.1 Application Data Feature).

3.2.2 Operation

This module specifies how to transmit "out of band" application data, as defined in the Application Data feature (see 3.1 Application Data Feature), as SOAP headers.
As a SOAP sender, if the property 'http://www.w3.org/2004/08/wsdl/feature/AD/data' has a value then each of the top-level child element information items in the value MUST be turned into a SOAP header. The elements are serialized according to their schemas, and if the "ad:mustUnderstand" attribute exists with the value "true" on any given element declaration, that particular SOAP header should be marked as "mustUnderstand='true'" or "mustUnderstand='1'" as per the SOAP specification. SOAP senders SHOULD also add an additional header, with namespace 'http://www.w3.org/2004/08/wsdl/module/AD' and local name "dataHeaders" - this header contains a list of element QNames, one for each application data header created in the first step.
It is the responsibility of the receiving node to determine which, if any, SOAP headers will populate the 'http://www.w3.org/2004/08/wsdl/feature/AD/data' property. Typically this will be accomplished via using some metadata, such as an understanding of a constraint specified in WSDL, or out-of-band agreements. If the "dataHeaders" SOAP header (described above) is present, the QNames inside that header indicate which other headers are application data. The contents of each SOAP header identified as application data will be placed in a child element of the data property.

3.3 Application data serialization as HTTP headers

3.3.1 Name

This feature-binding is identified with the URI 'http://www.w3.org/2004/08/wsdl/feature/AD-HTTP'

3.3.2 Features Implemented

This module implements the feature 'http://www.w3.org/2004/08/wsdl/feature/AD' (see 3.1 Application Data Feature).

3.3.3 Operation

This section specifies how to transmit "out of band" application data, defined in the Application Data Feature (see 3.1 Application Data Feature) as HTTP headers.
If the property 'http://www.w3.org/2004/08/wsdl/feature/AD/data' has a value for a message to be serialized as an HTTP message, then each of the top-level child element information items indicates an element information item that MUST be turned into an HTTP header if possible.
Only element information items of type "xs:string" or "xs:anyURI" may be serialized. All complex data types are ignored. Attributes on data elements are ignored.
Each such element information item is serialized as follows:
  • The HTTP header name used is the element information item local name. The element information item local name MUST follow the field-name production rules as specified in section 4.2 of [IETF RFC 2616]; if not, the element information item MUST be ignored. If an HTTP header corresponding to the element information item local name is set by a mechanism other than the Application Data Feature (see 3.1 Application Data Feature), such as the HTTP stack or another feature, then an error MUST be raised.
  • The HTTP header content is serialized from the element information item value in UTF-8. If this serialization is NOT possible, then the element information item MUST be ignored.
It is the responsibility of the receiving node to determine which, if any, HTTP headers will populate the 'http://www.w3.org/2004/08/wsdl/feature/AD/data' property. Typically this will be accomplished via some metadata, such as a {property constraint} specified in [WSDL 2.0 Core Language], or out-of-band agreements. The content of each such HTTP header will be placed in a child element of the data property. Each child element information item is generated by using the HTTP header name as the element information item local name and the HTTP header value as the element information item value.
Note:
The local name of the element information item which is the parent node of the element information items received, as well as the namespace of those element information items, are implementation-specific.

4. References

4.1 Normative References

[IETF RFC 2119]
Key words for use in RFCs to Indicate Requirement Levels, S. Bradner, Author. Internet Engineering Task Force, June 1999. Available at http://www.ietf.org/rfc/rfc2119.txt.
[IETF RFC 2616]
Hypertext Transfer Protocol -- HTTP/1.1, R. Fielding, J. Gettys, J. Mogul, H. Frystyk, L. Masinter, P. Leach, T. Berners-Lee, Authors. Internet Engineering Task Force, June 1999. Available at http://www.ietf.org/rfc/rfc2616.txt.
[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, 3 August 2004. 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/2004/WD-wsdl20-20040803. 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.

4.2 Informative References

[WSD Requirements]
Web Services Description Requirements, J. Schlimmer, Editor. World Wide Web Consortium, 28 October 2002. This version of the Web Services Description Requirements document is http://www.w3.org/TR/2002/WD-ws-desc-reqs-20021028. The latest version of Web Services Description Requirements is available at http://www.w3.org/TR/ws-desc-reqs.

A. Acknowledgements (Non-Normative)

This document is the work of the W3C Web Service Description Working Group.
Members of the Working Group are (at the time of writing, and by alphabetical order): David Booth (W3C), Allen Brookes (Rogue Wave Softwave), Helen Chen (Agfa-Gevaert N. V.), Roberto Chinnici (Sun Microsystems), Ugo Corda (SeeBeyond), Glen Daniels (Sonic Software), Paul Downey (British Telecommunications), Youenn Fablet (Canon), Martin Gudgin (Microsoft Corporation), Hugo Haas (W3C), Hao He (The Thomson Corporation), Tom Jordahl (Macromedia), Jacek Kopecky (Digital Enterprise Research Institute (DERI)), Amelia Lewis (TIBCO Software, Inc.), Kevin Canyang Liu (SAP), Jonathan Marsh (Microsoft Corporation), Peter Madziak (Agfa-Gevaert N. V.), Josephine Micallef (SAIC - Telcordia Technologies), Jeff Mischkinsky (Oracle Corporation), Dale Moberg (Cyclone Commerce), Jean-Jacques Moreau (Canon), Mark Nottingham (BEA Systems, Inc.), David Orchard (BEA Systems, Inc.), Bijan Parsia (University of Maryland), Arthur Ryman (IBM), Adi Sakala (IONA Technologies), Jeffrey Schlimmer (Microsoft Corporation), Igor Sedukhin (Computer Associates), Jerry Thrasher (Lexmark), William Vambenepe (Hewlett-Packard Company), Asir Vedamuthu (webMethods, Inc.), Sanjiva Weerawarana (IBM), Ümit Yalçınalp (Oracle Corporation), Prasad Yendluri (webMethods, Inc.).
Previous members were: Lily Liu (webMethods, Inc.), Don Wright (Lexmark), Joyce Yang (Oracle Corporation), Daniel Schutzer (Citigroup), Dave Solo (Citigroup), Stefano Pogliani (Sun Microsystems), William Stumbo (Xerox), Stephen White (SeeBeyond), Barbara Zengler (DaimlerChrysler Research and Technology), Tim Finin (University of Maryland), Laurent De Teneuille (L'Echangeur), Johan Pauhlsson (L'Echangeur), Mark Jones (AT&T), Steve Lind (AT&T), Sandra Swearingen (U.S. Department of Defense, U.S. Air Force), Philippe Le Hégaret (W3C), Jim Hendler (University of Maryland), Dietmar Gaertner (Software AG), Michael Champion (Software AG), Don Mullen (TIBCO Software, Inc.), Steve Graham (Global Grid Forum), Steve Tuecke (Global Grid Forum), Michael Mahan (Nokia), Bryan Thompson (Hicks & Associates), Ingo Melzer (DaimlerChrysler Research and Technology), Sandeep Kumar (Cisco Systems), Alan Davies (SeeBeyond), Jacek Kopecky (Systinet), Mike Ballantyne (Electronic Data Systems), Mike Davoren (W. W. Grainger), Dan Kulp (IONA Technologies), Mike McHugh (W. W. Grainger), Michael Mealling (Verisign), Waqar Sadiq (Electronic Data Systems), Yaron Goland (BEA Systems, Inc.).
The people who have contributed to discussions on www-ws-desc@w3.org are also gratefully acknowledged.

B. Change Log (Non-Normative)

B.1 Changes


DateAuthorDescription
20040713aalimplement editorial changes requested after review by GlenD, in application data feature and module.
20040713aaladdress issues 233 & 112 all at once, by increasing level of all divs, adding new intro div, adding new div to contain features, renaming spec. Lotsa changes, what fun.
20040713aals/Label/Message Label/g and s/{label}/{message label}/g. issue 230.
20040713aalreplace "fault generation" with "fault propagation" (in almost all cases; one case of "generate" remains to indicate that it ends an exchange). issue 234.
20040713aaladd language to introduction describing relationship between these MEPs and the MEPs defined by SOAP 1.2 (issue 232). This replaces the language found two items down (issue 191).
20040713aaladd (hereafter, simply 'patterns') to intro (issue 231).
20040610aaladd language to introduction describing relationship between these MEPs and the MEPs defined by SOAP 1.2 (issue 191).
20040225aaladd in-optional-out per minutes of 20 feb 2004 telecon
20040212aalchange {messageReference} to {label} and "Message Reference component" to "Label component" per 20040212 teleconference
20040205aalchange all 'A' and 'B' message labels into 'Out' or 'In', depending upon direction.
20040205aals/message pattern/message exchange pattern/gi
20031204jcsRemoved change marks; note that some were on div2 tag and did not show when transformed into HTML.
20031204jcsPer 4 Dec 2003 telecon, decided to rename 'Asynchronous Out-In' pattern to 'Output-Optional-Input'.
20031105aalFix titles of added patterns. Move them to be in conjunction with similar patterns.
20031022aalPer action item from October 16 teleconference, added the three patterns using message-triggers-fault as published on the mailing list (robust-in-only, robust-out-only, asynch-out-in).
20031022aalAdded internal linkage (using specref) from patterns to the fault rulesets which they use.
20031022aalPer 9 and 16 Oct 2003 teleconferences, marked in-multi-out and out-multi-in patterns deleted.
20031022aalPer 16 Oct 2003 teleconference, added a paragraph/sentence stating that generation of a fault terminates an exchange.
20031007JCSPer 2 Oct 2003 teleconference, changed "broadcast" to "multicast" in the introduction.
20030922JCSPer 22 Sep 2003 meeting in Palo Alto, CA, removed "Pattern Review" editorial note; added specific editorial notes for In-Multi-Out and Out-Multi-In.
20030911RRCChanged the "name" property of the message reference component to "messageReference".
20030904JCSIncorporated clarifications suggested by W3C\David Booth.
20030801JCSPer 30 July meeting, added recommendations from patterns task force.
20030612AALAdded fault generation rulesets and references to them from patterns.
20030313MJGChanged to Part 2 ( from Part 3 )
20030306JCSProposed name for MEP7.
20030305JCSPer 4 Mar 03 meeting, renamed 'message exchange pattern' to 'message pattern' or 'pattern', added pattern for request-response, added ednote about review of patterns.
20030217MJGFixed some issues with entities and validity errors WRT ulists
20030212JCSInitial draft

Service Oriented Architecture (SOA)

http://www.ibm.com/developerworks/library/ws-soaintro/index.html

Service-Oriented Architecture expands the vision of web services, Part 1

Characteristics of Service-Oriented Architecture
Today's web services implementations are typically simple and often similar to a client-server model. However, platform-neutral interchange is supported, which allows a diverse range of client implementations to interact with new or legacy code as server functions. Much has been written about the technologies that make such applications straightforward to implement. It is now time to look at the bigger picture of what we can do with them. The author addresses the question of how to move forward from simple models to those that represent real-world business models of arbitrary complexity.
Mark Colan (mcolan@us.ibm.com), e-business evangelist, IBM Corporation
21 April 2004
Also available in
In 221B.C., Emperor Qin unified several formerly warring states into a new country, which we now call China. Perhaps one reason China has endured as a nation was Qin’s introduction of standards, which consolidated cultures and facilitated trade: a standard distance for wheels on carts which allowed them to travel efficiently on any road, a common written language that everybody could use to exchange messages (even if they did not speak the same language), and a strong defense against outside attacks (like the Great Wall of China). You could say that he developed the models for standardized transport, message exchange, and the firewall.
In the same way, business integration of modern times has benefited from standards that enable heterogeneous computer systems to interoperate efficiently. These technologies are referred to, collectively, as web services. The dawn of web services was marked by the introduction of SOAP 1.1, which defined the use of XML content for interaction in distributed systems while hiding the implementation details. Four years later, many companies are using web services, and you could safely say that the industry is at the beginning of the web services mainstream era.
IBM sees Service-Oriented Architecture (SOA) as key to interoperability and flexibility requirements for its vision of on demand business. SOA supports end-to-end integration across the enterprise and among business partners. This provides a flexible business process model that allows customers to respond quickly to new customer requirements, new business opportunities, and competitive threats.

What is SOA?

SOA presents the big picture of what you can do with web services. Web services specifications define the details needed to implement services and interact with them. However, SOA is an approach to build distributed systems that deliver application functionality as services to end-user applications or to build other services. SOA can be based on web services, but it may use other technologies instead. In using SOA to design distributed applications, you can expand the use of web services from simple client-server models to systems of arbitrary complexity.
Thus, individual software assets become the building blocks to develop other applications. You can reduce the complexity of systems by using a common style of interaction that works with both new and legacy code (Lawrence Wilkes, of CBDi, has joked that SOA could stand for “Save Our Assets" ). There is a standard way of representing and interacting with these software assets; now the focus shifts to application assembly based on these building blocks.
While discussing SOA for business applications here, SOA is also being used for other distributed systems such as grid computing and advanced web services specifications (for example, WS-DistributedManagement, WS-Trust, and UDDI).

What is a service?

service in SOA is an application function packaged as a reusable component for use in a business process. It either provides information or facilitates a change to business data from one valid and consistent state to another. The process used to implement a particular service does not matter, as long as it responds to your commands and offers the quality of service you require.
Through defined communication protocols, services can be invoked that stress interoperability and location transparency. A service has the appearance of a software component, in that it looks like a self-contained function from the service requester's perspective. However, the service implementation may actually involve many steps executed on different computers within one enterprise or on computers owned by a number of business partners. A service might or might not be a component in the sense of encapsulated software. Like a class object, the requester application is capable of treating the service as one.
Web services are based on invocation using SOAP messages which are described using WSDL over a standard protocol such as HTTP. Use of web services is a best practice when communicating with external business partners.

Loose coupling

The binding from the service requester to the service provider should loosely couple the service. This means that the service requester has no knowledge of the technical details of the provider’s implementation, such as the programming language, deployment platform, and so forth. The service requester typically invokes operations by way of messages -- a request message and the response -- rather than through the use of APIs or file formats.
This loose coupling allows software on each side of the conversation to change without impacting the other, provided that the message schema stays the same. In an extreme case, a service provider could replace an early implementation based on legacy code, such as COBOL, with an entirely new code base based on Java language without having any impact on the service requester. This case is true as long as the new code supports the same message schema.

Well-defined interfaces

The service interaction must be well-defined. Web services Description Language (WSDL) is a widely-supported way of describing the details required by a service requester for binding to a service provider. The service descriptions focus on operations used to interact with the following:
  • A service
  • Messages to invoke operations
  • Details of constructing such messages
  • Information on where to send messages for processingetails of constructing such messages
WSDL does not include any technology details of the implementation of a service. The service requester neither knows nor cares whether the service is written in Java code, C#, COBOL, or some other programming language. It can describe a SOAP invocation using HTTP. Because of its extension mechanisms, it can also define other styles of interaction such as XML content delivered via JMS, direct method calls, calls handled by an adapter that manages legacy code (CICS), and so forth.
The common definition for WSDL allows development tools to create common interfaces for various styles of interaction, while hiding the details of how it invokes the service from the application code. The Web Services Invocation Framework (WSIF), for example, exploits this capability by allowing a run-time determination of the best way to invoke a quality service if the service is exposed in more than one interaction style.

Stateless service design

Services should be independent, self-contained requests, which do not require information or state from one request to another when implemented. Services should not be dependent on the context or state of other services. When dependencies are required, they are best defined in terms of common business processes, functions, and data models, not implementation artifacts (like a session key). Of course, requester applications require persistent state between service invocations, but this should be separate from the service provider.
Here is an example of the wrong way to define a conversation:
Requester: “What is Bruce’s checking account balance?"
Provider: “$x"
Requester: “And what is his credit limit?"
Provider: “$y"
The provider is required to remember Bruce’s account between requests, which introduces complexity into the service implementation. Stateless service design would redefine the conversation as follows:
Requester: “What is Bruce’s checking account balance?"
Provider: “$x"
Requester: “What is Bruce’s credit limit?"
Provider: “$y"

Service granularity

The granularity of operations is an important design point. The use of coarse-grained interfaces for external consumption is recommended, whereas fine-grained interfaces might be used inside the enterprise. A coarse-grained interface might be the complete processing for a given service, such as SubmitPurchaseOrder, where the message contains all of the business information needed to define a purchase order. A fine-grained interface might have separate operations for: CreateNewPurchaseOrderSetShippingAddressAddItem, and so forth.
While the fine-grained interface offers more flexibility to the requester application, it also means that patterns of interaction may vary between different service requesters. This can make support more difficult for the service provider. A coarse-grained interface guarantees that the service requesters will use the service in a consistent manner. SOA does not require the use of coarse-grained interfaces, but recommends their use as a best practice for external integration. Service choreography can be used to create a coarse-grained interface that runs a business process consisting of fine-grained operations.

Quality of service considerations

SOA designs will span computer systems and might cross enterprise lines. You have to think about the security capabilities and requirements when using the Internet and how to link across partners’ security domains. Internet protocols are not designed for reliability (guaranteed delivery and order of delivery), but you have to ensure that a message is delivered and processed one time. When this is not possible, the requester must know that a request has not been processed.
For example, you may need to consider metering, availability, and response time of services you deploy in order to ensure that they are within the promised range. As you design systems that use services from other business partners, you have to consider service-oriented management to cooperatively manage services among partners.

Conclusion

This article has focused on the advantages of SOA for expanding the value of software assets, while managing complexity in distributed applications. It has also defined the nature of services and examined their characteristics, as well as a few best practices.
The next article will examine architectural concepts of SOA from the following list:
  • Service invocation and description to discovery
  • The broker model
  • Internal integration
  • Externalization of services

Resources

Monday, January 13, 2014

BPEL , orchestration and choregraphy

http://en.wikipedia.org/wiki/Business_Process_Execution_Language

The BPEL language[edit]

BPEL is an orchestration language, and not a choreography language. The primary difference between orchestration and choreography is executability and control. An orchestration specifies an executable process that involves message exchanges with other systems, such that the message exchange sequences are controlled by the orchestration designer. A choreography specifies a protocol for peer-to-peer interactions, defining, e.g., the legal sequences of messages exchanged with the purpose of guaranteeing interoperability. Such a protocol is not directly executable, as it allows many different realizations (processes that comply with it). A choreography can be realized by writing an orchestration (e.g., in the form of a BPEL process) for each peer involved in it. The orchestration and the choreography distinctions are based on analogies: orchestration refers to the central control (by the conductor) of the behavior of a distributed system (the orchestra consisting of many players), while choreography refers to a distributed system (the dancing team) which operates according to rules (the choreography) but without centralized control.
BPEL's focus on modern business processes, plus the histories of WSFL and XLANG, led BPEL to adopt web services as its external communication mechanism. Thus BPEL's messaging facilities depend on the use of the Web Services Description Language (WSDL) 1.1 to describe outgoing and incoming messages.
In addition to providing facilities to enable sending and receiving messages, the BPEL programming language also supports:
  • A property-based message correlation mechanism
  • XML and WSDL typed variables
  • An extensible language plug-in model to allow writing expressions and queries in multiple languages: BPEL supports XPath 1.0 by default
  • Structured-programming constructs including if-then-elseif-else, while, sequence (to enable executing commands in order) and flow (to enable executing commands in parallel)
  • scoping system to allow the encapsulation of logic with local variables, fault-handlers, compensation-handlers and event-handlers
  • Serialized scopes to control concurrent access to variables.

Saturday, January 11, 2014

Error 400 Pushing my Repository to Github in windows 7 64 bit

error: The requested URL returned error: 400 while accessing https://github.com/jkasaudhan/projects.git[branch master]/info/refs
fatal: HTTP request failed 

Solution: 
  1. Changed ssh key configuration in github 
  •  Open git bash, type ssh-keygen -t rsa  then y , enter enter ,enter .
  •  Then cat ~/.ssh/id_rsa.pub and copy the ssh key all as it is and paste it to github web interface on                  Account    setting>>ssh key 
  • removed old origin using command - git remote rm origin 
  • added new origin with ssh url using command -            git remote add origin git@github.com:jkasaudhan/projects.git
  •  do not place url with https://.....rather use ssh url type
  •   push to repo using command git push origin master. It worked !!!