ࡱ > q
s
\
]
^
_
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
%` w bjbj"x"x n
@ @ ]k k " ( 4 % h t% $ % $ $ $ P t
t % H) ) J. d . . . / y $ \ u( w( w( w( w( w( w( $ , h ( $ / / \ ( . . 4 ( P _ _ _ , 4 . . u( _ u( _ _ r 1 T . @BN $ P2 ) H H) 0 0I 0 0 \# _ ( ( W H) % % 5 |[ d ) D % % |[ ) % % %
Service Component Architecture Assembly Model Specification Version 1.1
Committee Draft 01 Revision 3 + Issue 90
18th November 2008
Specification URIs:
This Version:
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.html" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.html
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.doc" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.doc
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.pdf" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec-cd01.pdf (Authoritative)
Previous Version:
Latest Version:
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.html" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.html
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.doc" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.doc
HYPERLINK "http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.pdf" http://docs.oasis-open.org/opencsa/sca-assembly/sca-assembly-1.1-spec.pdf (Authoritative)
Latest Approved Version:
Technical Committee:
HYPERLINK "http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=sca-assembly"OASIS Service Component Architecture / Assembly (SCA-Assembly) TC
Chair(s):
Martin Chapman, Oracle
Mike Edwards, IBM
Editor(s):
Michael Beisiegel, IBM
Khanderao Khand, Oracle
Anish Karmarkar, Oracle
Sanjay Patil, SAP
Michael Rowley, BEA Systems
Related work:
This specification replaces or supercedes:
Service Component Architecture Assembly Model Specification Version 1.00, March 15, 2007
This specification is related to:
Service Component Architecture Policy Framework Specification Version 1.1
Declared XML Namespace(s):
HYPERLINK "http://docs.oasis-open.org/ns/opencsa/sca/200712" http://docs.oasis-open.org/ns/opencsa/sca/200712
Abstract:
Service Component Architecture (SCA) provides a programming model for building applications and solutions based on a Service Oriented Architecture. It is based on the idea that business function is provided as a series of services, which are assembled together to create solutions that serve a particular business need. These composite applications can contain both new services created specifically for the application and also business function from existing systems and applications, reused as part of the composition. SCA provides a model both for the composition of services and for the creation of service components, including the reuse of existing application function within SCA composites.
SCA is a model that aims to encompass a wide range of technologies for service components and for the access methods which are used to connect them. For components, this includes not only different programming languages, but also frameworks and environments commonly used with those languages. For access methods, SCA compositions allow for the use of various communication and service access technologies that are in common use, including, for example, Web services, Messaging systems and Remote Procedure Call (RPC).
The SCA Assembly Model consists of a series of artifacts which define the configuration of an SCA domain in terms of composites which contain assemblies of service components and the connections and related artifacts which describe how they are linked together.
This document describes the SCA Assembly Model, which covers
A model for the assembly of services, both tightly coupled and loosely coupled
A model for applying infrastructure capabilities to services and to service interactions, including Security and Transactions
Status:
This document was last revised or approved by the OASIS Service Component Architecture / Assembly (SCA-Assembly) TC on the above date. The level of approval is also listed above. Check the Latest Version or Latest Approved Version location noted above for possible later revisions of this document.
Technical Committee members should send comments on this specification to the Technical Committees email list. Others should send comments to the Technical Committee by using the Send A Comment button on the Technical Committees web page at HYPERLINK "http://www.oasis-open.org/committees/sca-assembly/"http://www.oasis-open.org/committees/sca-assembly/.
For information on whether any patents have been disclosed that may be essential to implementing this specification, and any offers of patent licensing terms, please refer to the Intellectual Property Rights section of the Technical Committee web page (HYPERLINK "http://www.oasis-open.org/committees/sca-assembly/"http://www.oasis-open.org/committees/sca-assembly/ipr.php.
The non-normative errata page for this specification is located at HYPERLINK "http://www.oasis-open.org/committees/sca-assembly/"http://www.oasis-open.org/committees/sca-assembly/
Notices
Copyright OASIS 2005, 2008. All Rights Reserved.
All capitalized terms in the following text have the meanings assigned to them in the OASIS Intellectual Property Rights Policy (the "OASIS IPR Policy"). The full Policy may be found at the OASIS website.
This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published, and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this section are included on all such copies and derivative works. However, this document itself may not be modified in any way, including by removing the copyright notice or references to OASIS, except as needed for the purpose of developing any document or deliverable produced by an OASIS Technical Committee (in which case the rules applicable to copyrights, as set forth in the OASIS IPR Policy, must be followed) or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by OASIS or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
OASIS requests that any OASIS Party or any other party that believes it has patent claims that would necessarily be infringed by implementations of this OASIS Committee Specification or OASIS Standard, to notify OASIS TC Administrator and provide an indication of its willingness to grant patent licenses to such patent claims in a manner consistent with the IPR Mode of the OASIS Technical Committee that produced this specification.
OASIS invites any party to contact the OASIS TC Administrator if it is aware of a claim of ownership of any patent claims that would necessarily be infringed by implementations of this specification by a patent holder that is not willing to provide a license to such patent claims in a manner consistent with the IPR Mode of the OASIS Technical Committee that produced this specification. OASIS may include such claims on its website, but disclaims any obligation to do so.
OASIS takes no position regarding the validity or scope of any intellectual property or other rights that might be claimed to pertain to the implementation or use of the technology described in this document or the extent to which any license under such rights might or might not be available; neither does it represent that it has made any effort to identify any such rights. Information on OASIS' procedures with respect to rights in any document or deliverable produced by an OASIS Technical Committee can be found on the OASIS website. Copies of claims of rights made available for publication and any assurances of licenses to be made available, or the result of an attempt made to obtain a general license or permission for the use of such proprietary rights by implementers or users of this OASIS Committee Specification or OASIS Standard, can be obtained from the OASIS TC Administrator. OASIS makes no representation that any information or list of intellectual property rights will at any time be complete, or that any claims in such list are, in fact, Essential Claims.
The names "OASIS", MACROBUTTON NoMacro [insert specific trademarked names and abbreviations here] are trademarks of OASIS, the owner and developer of this specification, and should be used only to refer to the organization and its official outputs. OASIS welcomes reference to, and implementation and use of, specifications, while reserving the right to enforce its marks against misleading uses. Please see HYPERLINK "http://www.oasis-open.org/who/trademark.php" http://www.oasis-open.org/who/trademark.php for above guidance.
Table of Contents
TOC \o "1-3" \h \z \u HYPERLINK \l "_Toc214771344" Committee Draft 01 Revision 3 PAGEREF _Toc214771344 \h 1
HYPERLINK \l "_Toc214771345" The non-normative errata page for this specification is located at http://www.oasis-open.org/committees/sca-assembly/ PAGEREF _Toc214771345 \h 3
HYPERLINK \l "_Toc214771346" Notices PAGEREF _Toc214771346 \h 4
HYPERLINK \l "_Toc214771347" Table of Contents PAGEREF _Toc214771347 \h 5
HYPERLINK \l "_Toc214771348" 1 Introduction PAGEREF _Toc214771348 \h 8
HYPERLINK \l "_Toc214771349" 1.1 Terminology PAGEREF _Toc214771349 \h 8
HYPERLINK \l "_Toc214771350" 1.2 Normative References PAGEREF _Toc214771350 \h 8
HYPERLINK \l "_Toc214771351" 2 Overview PAGEREF _Toc214771351 \h 10
HYPERLINK \l "_Toc214771352" 2.1 Diagram used to Represent SCA Artifacts PAGEREF _Toc214771352 \h 11
HYPERLINK \l "_Toc214771353" 3 Quick Tour by Sample PAGEREF _Toc214771353 \h 13
HYPERLINK \l "_Toc214771354" 4 Implementation and ComponentType PAGEREF _Toc214771354 \h 14
HYPERLINK \l "_Toc214771355" 4.1 Component Type PAGEREF _Toc214771355 \h 14
HYPERLINK \l "_Toc214771356" 4.1.1 Service PAGEREF _Toc214771356 \h 15
HYPERLINK \l "_Toc214771357" 4.1.2 Reference PAGEREF _Toc214771357 \h 16
HYPERLINK \l "_Toc214771358" 4.1.3 Property PAGEREF _Toc214771358 \h 18
HYPERLINK \l "_Toc214771359" 4.1.4 Implementation PAGEREF _Toc214771359 \h 19
HYPERLINK \l "_Toc214771360" 4.2 Example ComponentType PAGEREF _Toc214771360 \h 20
HYPERLINK \l "_Toc214771361" 4.3 Example Implementation PAGEREF _Toc214771361 \h 20
HYPERLINK \l "_Toc214771362" 5 Component PAGEREF _Toc214771362 \h 23
HYPERLINK \l "_Toc214771363" 5.1 Implementation PAGEREF _Toc214771363 \h 24
HYPERLINK \l "_Toc214771364" 5.2 Service PAGEREF _Toc214771364 \h 25
HYPERLINK \l "_Toc214771365" 5.3 Reference PAGEREF _Toc214771365 \h 27
HYPERLINK \l "_Toc214771366" 5.3.1 Specifying the Target Service(s) for a Reference PAGEREF _Toc214771366 \h 29
HYPERLINK \l "_Toc214771367" 5.4 Property PAGEREF _Toc214771367 \h 30
HYPERLINK \l "_Toc214771368" 5.5 Example Component PAGEREF _Toc214771368 \h 33
HYPERLINK \l "_Toc214771369" 6 Composite PAGEREF _Toc214771369 \h 37
HYPERLINK \l "_Toc214771370" 6.1 Service PAGEREF _Toc214771370 \h 39
HYPERLINK \l "_Toc214771371" 6.1.1 Service Examples PAGEREF _Toc214771371 \h 40
HYPERLINK \l "_Toc214771372" 6.2 Reference PAGEREF _Toc214771372 \h 42
HYPERLINK \l "_Toc214771373" 6.2.1 Example Reference PAGEREF _Toc214771373 \h 44
HYPERLINK \l "_Toc214771374" 6.3 Property PAGEREF _Toc214771374 \h 46
HYPERLINK \l "_Toc214771375" 6.3.1 Property Examples PAGEREF _Toc214771375 \h 47
HYPERLINK \l "_Toc214771376" 6.4 Wire PAGEREF _Toc214771376 \h 50
HYPERLINK \l "_Toc214771377" 6.4.1 Wire Examples PAGEREF _Toc214771377 \h 52
HYPERLINK \l "_Toc214771378" 6.4.2 Autowire PAGEREF _Toc214771378 \h 54
HYPERLINK \l "_Toc214771379" 6.4.3 Autowire Examples PAGEREF _Toc214771379 \h 55
HYPERLINK \l "_Toc214771380" 6.5 Using Composites as Component Implementations PAGEREF _Toc214771380 \h 58
HYPERLINK \l "_Toc214771381" 6.5.1 Example of Composite used as a Component Implementation PAGEREF _Toc214771381 \h 60
HYPERLINK \l "_Toc214771382" 6.6 Using Composites through Inclusion PAGEREF _Toc214771382 \h 61
HYPERLINK \l "_Toc214771383" 6.6.1 Included Composite Examples PAGEREF _Toc214771383 \h 62
HYPERLINK \l "_Toc214771384" 6.7 Composites which Include Component Implementations of Multiple Types PAGEREF _Toc214771384 \h 65
HYPERLINK \l "_Toc214771385" 7 ConstrainingType PAGEREF _Toc214771385 \h 66
HYPERLINK \l "_Toc214771386" 7.1 Example constrainingType PAGEREF _Toc214771386 \h 67
HYPERLINK \l "_Toc214771387" 8 Interface PAGEREF _Toc214771387 \h 69
HYPERLINK \l "_Toc214771388" 8.1 Local and Remotable Interfaces PAGEREF _Toc214771388 \h 70
HYPERLINK \l "_Toc214771389" 8.2 Bidirectional Interfaces PAGEREF _Toc214771389 \h 71
HYPERLINK \l "_Toc214771390" 8.3 Conversational Interfaces PAGEREF _Toc214771390 \h 71
HYPERLINK \l "_Toc214771391" 8.4 SCA-Specific Aspects for WSDL Interfaces PAGEREF _Toc214771391 \h 73
HYPERLINK \l "_Toc214771392" 9 Binding PAGEREF _Toc214771392 \h 75
HYPERLINK \l "_Toc214771393" 9.1 Messages containing Data not defined in the Service Interface PAGEREF _Toc214771393 \h 77
HYPERLINK \l "_Toc214771394" 9.2 Form of the URI of a Deployed Binding PAGEREF _Toc214771394 \h 77
HYPERLINK \l "_Toc214771395" 9.2.1 Constructing Hierarchical URIs PAGEREF _Toc214771395 \h 77
HYPERLINK \l "_Toc214771396" 9.2.2 Non-hierarchical URIs PAGEREF _Toc214771396 \h 78
HYPERLINK \l "_Toc214771397" 9.2.3 Determining the URI scheme of a deployed binding PAGEREF _Toc214771397 \h 78
HYPERLINK \l "_Toc214771398" 9.3 SCA Binding PAGEREF _Toc214771398 \h 79
HYPERLINK \l "_Toc214771399" 9.3.1 Example SCA Binding PAGEREF _Toc214771399 \h 79
HYPERLINK \l "_Toc214771400" 9.4 Web Service Binding PAGEREF _Toc214771400 \h 80
HYPERLINK \l "_Toc214771401" 9.5 JMS Binding PAGEREF _Toc214771401 \h 80
HYPERLINK \l "_Toc214771402" 10 SCA Definitions PAGEREF _Toc214771402 \h 81
HYPERLINK \l "_Toc214771403" 11 Extension Model PAGEREF _Toc214771403 \h 82
HYPERLINK \l "_Toc214771404" 11.1 Defining an Interface Type PAGEREF _Toc214771404 \h 82
HYPERLINK \l "_Toc214771405" 11.2 Defining an Implementation Type PAGEREF _Toc214771405 \h 84
HYPERLINK \l "_Toc214771406" 11.3 Defining a Binding Type PAGEREF _Toc214771406 \h 85
HYPERLINK \l "_Toc214771407" 12 Packaging and Deployment PAGEREF _Toc214771407 \h 88
HYPERLINK \l "_Toc214771408" 12.1 Domains PAGEREF _Toc214771408 \h 88
HYPERLINK \l "_Toc214771409" 12.2 Contributions PAGEREF _Toc214771409 \h 88
HYPERLINK \l "_Toc214771410" 12.2.1 SCA Artifact Resolution PAGEREF _Toc214771410 \h 89
HYPERLINK \l "_Toc214771411" 12.2.2 SCA Contribution Metadata Document PAGEREF _Toc214771411 \h 90
HYPERLINK \l "_Toc214771412" 12.2.3 Contribution Packaging using ZIP PAGEREF _Toc214771412 \h 92
HYPERLINK \l "_Toc214771413" 12.3 Installed Contribution PAGEREF _Toc214771413 \h 92
HYPERLINK \l "_Toc214771414" 12.3.1 Installed Artifact URIs PAGEREF _Toc214771414 \h 92
HYPERLINK \l "_Toc214771415" 12.4 Operations for Contributions PAGEREF _Toc214771415 \h 93
HYPERLINK \l "_Toc214771416" 12.4.1 install Contribution & update Contribution PAGEREF _Toc214771416 \h 93
HYPERLINK \l "_Toc214771417" 12.4.2 add Deployment Composite & update Deployment Composite PAGEREF _Toc214771417 \h 93
HYPERLINK \l "_Toc214771418" 12.4.3 remove Contribution PAGEREF _Toc214771418 \h 93
HYPERLINK \l "_Toc214771419" 12.5 Use of Existing (non-SCA) Mechanisms for Resolving Artifacts PAGEREF _Toc214771419 \h 93
HYPERLINK \l "_Toc214771420" 12.6 Domain-Level Composite PAGEREF _Toc214771420 \h 94
HYPERLINK \l "_Toc214771421" 12.6.1 add To Domain-Level Composite PAGEREF _Toc214771421 \h 94
HYPERLINK \l "_Toc214771422" 12.6.2 remove From Domain-Level Composite PAGEREF _Toc214771422 \h 95
HYPERLINK \l "_Toc214771423" 12.6.3 get Domain-Level Composite PAGEREF _Toc214771423 \h 95
HYPERLINK \l "_Toc214771424" 12.6.4 get QName Definition PAGEREF _Toc214771424 \h 95
HYPERLINK \l "_Toc214771425" 13 Conformance PAGEREF _Toc214771425 \h 96
HYPERLINK \l "_Toc214771426" A. Pseudo Schema PAGEREF _Toc214771426 \h 97
HYPERLINK \l "_Toc214771427" A.1 ComponentType PAGEREF _Toc214771427 \h 97
HYPERLINK \l "_Toc214771428" A.2 Composite PAGEREF _Toc214771428 \h 98
HYPERLINK \l "_Toc214771429" B. XML Schemas PAGEREF _Toc214771429 \h 100
HYPERLINK \l "_Toc214771430" B.1 sca.xsd PAGEREF _Toc214771430 \h 100
HYPERLINK \l "_Toc214771431" B.2 sca-core.xsd PAGEREF _Toc214771431 \h 100
HYPERLINK \l "_Toc214771432" B.3 sca-binding-sca.xsd PAGEREF _Toc214771432 \h 109
HYPERLINK \l "_Toc214771433" B.4 sca-interface-java.xsd PAGEREF _Toc214771433 \h 110
HYPERLINK \l "_Toc214771434" B.5 sca-interface-wsdl.xsd PAGEREF _Toc214771434 \h 110
HYPERLINK \l "_Toc214771435" B.6 sca-implementation-java.xsd PAGEREF _Toc214771435 \h 111
HYPERLINK \l "_Toc214771436" B.7 sca-implementation-composite.xsd PAGEREF _Toc214771436 \h 112
HYPERLINK \l "_Toc214771437" B.8 sca-definitions.xsd PAGEREF _Toc214771437 \h 112
HYPERLINK \l "_Toc214771438" B.9 sca-binding-webservice.xsd PAGEREF _Toc214771438 \h 113
HYPERLINK \l "_Toc214771439" B.10 sca-binding-jms.xsd PAGEREF _Toc214771439 \h 113
HYPERLINK \l "_Toc214771440" B.11 sca-policy.xsd PAGEREF _Toc214771440 \h 113
HYPERLINK \l "_Toc214771441" B.12 sca-contribution.xsd PAGEREF _Toc214771441 \h 113
HYPERLINK \l "_Toc214771442" C. SCA Concepts PAGEREF _Toc214771442 \h 115
HYPERLINK \l "_Toc214771443" C.1 Binding PAGEREF _Toc214771443 \h 115
HYPERLINK \l "_Toc214771444" C.2 Component PAGEREF _Toc214771444 \h 115
HYPERLINK \l "_Toc214771445" C.3 Service PAGEREF _Toc214771445 \h 115
HYPERLINK \l "_Toc214771446" C.3.1 Remotable Service PAGEREF _Toc214771446 \h 115
HYPERLINK \l "_Toc214771447" C.3.2 Local Service PAGEREF _Toc214771447 \h 116
HYPERLINK \l "_Toc214771448" C.4 Reference PAGEREF _Toc214771448 \h 116
HYPERLINK \l "_Toc214771449" C.5 Implementation PAGEREF _Toc214771449 \h 116
HYPERLINK \l "_Toc214771450" C.6 Interface PAGEREF _Toc214771450 \h 116
HYPERLINK \l "_Toc214771451" C.7 Composite PAGEREF _Toc214771451 \h 117
HYPERLINK \l "_Toc214771452" C.8 Composite inclusion PAGEREF _Toc214771452 \h 117
HYPERLINK \l "_Toc214771453" C.9 Property PAGEREF _Toc214771453 \h 117
HYPERLINK \l "_Toc214771454" C.10 Domain PAGEREF _Toc214771454 \h 117
HYPERLINK \l "_Toc214771455" C.11 Wire PAGEREF _Toc214771455 \h 117
HYPERLINK \l "_Toc214771456" D. Conformance Items PAGEREF _Toc214771456 \h 118
HYPERLINK \l "_Toc214771457" E. Acknowledgements PAGEREF _Toc214771457 \h 125
HYPERLINK \l "_Toc214771458" F. Non-Normative Text PAGEREF _Toc214771458 \h 126
HYPERLINK \l "_Toc214771459" G. Revision History PAGEREF _Toc214771459 \h 127
Introduction
This document describes the SCA Assembly Model, which covers
A model for the assembly of services, both tightly coupled and loosely coupled
A model for applying infrastructure capabilities to services and to service interactions, including Security and Transactions
The document starts with a short overview of the SCA Assembly Model.
The next part of the document describes the core elements of SCA, SCA components and SCA composites.
The final part of the document defines how the SCA assembly model can be extended.
This specification is defined in terms of Infoset and not in terms of XML 1.0, even though the specification uses XML 1.0 terminology. A mapping from XML to infoset is trivial and should be used for any non-XML serializations.
Terminology
The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL in this document are to be interpreted as described in REF rfc2119 \h [RFC2119].
Normative References
[RFC2119] S. Bradner, Key words for use in RFCs to Indicate Requirement Levels, HYPERLINK "http://www.ietf.org/rfc/rfc2119.txt" http://www.ietf.org/rfc/rfc2119.txt, IETF RFC 2119, March 1997.
[1] SCA Java Component Implementation Specification
SCA Java Common Annotations and APIs Specification
HYPERLINK "http://www.osoa.org/download/attachments/35/SCA_JavaComponentImplementation_V100.pdf"http://www.osoa.org/download/attachments/35/SCA_JavaComponentImplementation_V100.pdf
HYPERLINK "http://www.osoa.org/download/attachments/35/SCA_JavaAnnotationsAndAPIs_V100.pdf"http://www.osoa.org/download/attachments/35/SCA_JavaAnnotationsAndAPIs_V100.pdf
[2] SDO Specification
HYPERLINK "http://www.osoa.org/download/attachments/36/Java-SDO-Spec-v2.1.0-FINAL.pdf"http://www.osoa.org/download/attachments/36/Java-SDO-Spec-v2.1.0-FINAL.pdf
[3] SCA Example Code document
HYPERLINK "http://www.osoa.org/download/attachments/28/SCA_BuildingYourFirstApplication_V09.pdf" http://www.osoa.org/download/attachments/28/SCA_BuildingYourFirstApplication_V09.pdf
[4] JAX-WS Specification
HYPERLINK "http://jcp.org/en/jsr/detail?id=101" http://jcp.org/en/jsr/detail?id=101
[5] WS-I Basic Profile
HYPERLINK "http://www.ws-i.org/deliverables/workinggroup.aspx?wg=basicprofile" http://www.ws-i.org/deliverables/workinggroup.aspx?wg=basicprofile
[6] WS-I Basic Security Profile
HYPERLINK "http://www.ws-i.org/deliverables/workinggroup.aspx?wg=basicsecurity" http://www.ws-i.org/deliverables/workinggroup.aspx?wg=basicsecurity
[7] Business Process Execution Language (BPEL)
HYPERLINK "http://www.oasis-open.org/committees/documents.php?wg_abbrev=wsbpel" http://www.oasis-open.org/committees/documents.php?wg_abbrev=wsbpel
[8] WSDL Specification
WSDL 1.1: HYPERLINK "http://www.w3.org/TR/wsdl" http://www.w3.org/TR/wsdl
WSDL 2.0: HYPERLINK "http://www.w3.org/TR/wsdl20/" http://www.w3.org/TR/wsdl20/
[9] SCA Web Services Binding Specification
HYPERLINK "http://www.osoa.org/download/attachments/35/SCA_WebServiceBindings_V100.pdf"http://www.osoa.org/download/attachments/35/SCA_WebServiceBindings_V100.pdf
[10] SCA Policy Framework Specification
HYPERLINK "http://www.osoa.org/download/attachments/35/SCA_Policy_Framework_V100.pdf"http://www.osoa.org/download/attachments/35/SCA_Policy_Framework_V100.pdf
[11] SCA JMS Binding Specification
HYPERLINK "http://www.osoa.org/download/attachments/35/SCA_JMSBinding_V100.pdf"http://www.osoa.org/download/attachments/35/SCA_JMSBinding_V100.pdf
[12] ZIP Format Definition
HYPERLINK "http://www.pkware.com/documents/casestudies/APPNOTE.TXT" http://www.pkware.com/documents/casestudies/APPNOTE.TXT
[13] Infoset Specification
HYPERLINK "http://www.w3.org/TR/xml-infoset/" http://www.w3.org/TR/xml-infoset/
Overview
Service Component Architecture (SCA) provides a programming model for building applications and solutions based on a Service Oriented Architecture. It is based on the idea that business function is provided as a series of services, which are assembled together to create solutions that serve a particular business need. These composite applications can contain both new services created specifically for the application and also business function from existing systems and applications, reused as part of the composition. SCA provides a model both for the composition of services and for the creation of service components, including the reuse of existing application function within SCA composites.
SCA is a model that aims to encompass a wide range of technologies for service components and for the access methods which are used to connect them. For components, this includes not only different programming languages, but also frameworks and environments commonly used with those languages. For access methods, SCA compositions allow for the use of various communication and service access technologies that are in common use, including, for example, Web services, Messaging systems and Remote Procedure Call (RPC).
The SCA Assembly Model consists of a series of artifacts which define the configuration of an SCA domain in terms of composites which contain assemblies of service components and the connections and related artifacts which describe how they are linked together.
One basic artifact of SCA is the component, which is the unit of construction for SCA. A component consists of a configured instance of an implementation, where an implementation is the piece of program code providing business functions. The business function is offered for use by other components as services. Implementations can depend on services provided by other components these dependencies are called references. Implementations can have settable properties, which are data values which influence the operation of the business function. The component configures the implementation by providing values for the properties and by wiring the references to services provided by other components.
SCA allows for a wide variety of implementation technologies, including "traditional" programming languages such as Java, C++, and BPEL, but also scripting languages such as PHP and JavaScript and declarative languages such as XQuery and SQL.
SCA describes the content and linkage of an application in assemblies called composites. Composites can contain components, services, references, property declarations, plus the wiring that describes the connections between these elements. Composites can group and link components built from different implementation technologies, allowing appropriate technologies to be used for each business task. In turn, composites can be used as complete component implementations: providing services, depending on references and with settable property values. Such composite implementations can be used in components within other composites, allowing for a hierarchical construction of business solutions, where high-level services are implemented internally by sets of lower-level services. The content of composites can also be used as groupings of elements which are contributed by inclusion into higher-level compositions.
Composites are deployed within an SCA Domain. An SCA Domain typically represents a set of services providing an area of business functionality that is controlled by a single organization. As an example, for the accounts department in a business, the SCA Domain might cover all financial related function, and it might contain a series of composites dealing with specific areas of accounting, with one for customer accounts, another dealing with accounts payable. To help build and configure the SCA Domain, composites can be used to group and configure related artifacts.
SCA defines an XML file format for its artifacts. These XML files define the portable representation of the SCA artifacts. An SCA runtime might have other representations of the artifacts represented by these XML files. In particular, component implementations in some programming languages may have attributes or properties or annotations which can specify some of the elements of the SCA Assembly model. The XML files define a static format for the configuration of an SCA Domain. An SCA runtime might also allow for the configuration of the domain to be modified dynamically.
Diagram used to Represent SCA Artifacts
This document introduces diagrams to represent the various SCA artifacts, as a way of visualizing the relationships between the artifacts in a particular assembly. These diagrams are used in this document to accompany and illuminate the examples of SCA artifacts.
The following picture illustrates some of the features of an SCA component:
Figure SEQ Figure \* ARABIC 1: SCA Component Diagram
The following picture illustrates some of the features of a composite assembled using a set of components:
Figure SEQ Figure \* ARABIC 2: SCA Composite Diagram
The following picture illustrates an SCA Domain assembled from a series of high-level composites, some of which are in turn implemented by lower-level composites:
Figure SEQ Figure \* ARABIC 3: SCA Domain Diagram
Quick Tour by Sample
To be completed.
This section is intended to contain a sample which describes the key concepts of SCA.
Implementation and ComponentType
Component implementations are concrete implementations of business function which provide services and/or which make references to services provided elsewhere. In addition, an implementation can have some settable property values.
SCA allows a choice of any one of a wide range of implementation types, such as Java, BPEL or C++, where each type represents a specific implementation technology. The technology might not simply define the implementation language, such as Java, but might also define the use of a specific framework or runtime environment. Examples include SCA Composite, Java implementations done using the Spring framework or the Java EE EJB technology.
Services, references and properties are the configurable aspects of an implementation. SCA refers to them collectively as the component type.
Depending on the implementation type, the implementation can declare the services, references and properties that it has and it also might be able to set values for all the characteristics of those services, references and properties.
So, for example:
for a service, the implementation might define the interface, binding(s), a URI, intents, and policy sets, including details of the bindings
for a reference, the implementation might define the interface, binding(s), target URI(s), intents, policy sets, including details of the bindings
for a property the implementation might define its type and a default value
the implementation itself might define policy intents or concrete policy sets
The means by which an implementation declares its services, references and properties depend on the type of the implementation. For example, some languages like Java, provide annotations which can be used to declare this information inline in the code.
Most of the characteristics of the services, references and properties can be overridden by a component that uses and configures the implementation, or the component can decide not to override those characteristics. Some characteristics cannot be overridden, such as intents. Other characteristics, such as interfaces, can only be overridden in particular controlled ways (see HYPERLINK \l "_Component" the Component section for details).
Component Type
Component type represents the configurable aspects of an implementation. A component type consists of services that are offered, references to other services that can be wired and properties that can be set. The settable properties and the settable references to services are configured by a component which uses the implementation.
The component type is calculated in two steps where the second step adds to the information found in the first step. Step one is introspecting the implementation (if possible), including the inspection of implementation annotations (if available). Step two covers the cases where introspection of the implementation is not possible or where it does not provide complete information and it involves looking for an SCA component type file. Component type information found in the component type file must be compatible with the equivalent information found from inspection of the implementation. The component type file can specify partial information, with the remainder being derived from the implementation.
In the ideal case, the component type information is determined by inspecting the implementation, for example as code annotations. The component type file provides a mechanism for the provision of component type information for implementation types where the information cannot be determined by inspecting the implementation.
The component type is defined by a componentType element in the componentType file. The extension of a componentType file MUST be .componentType and its name and location depends on the type of the component implementation: the specifics are described in the respective client and implementation model specification for the implementation type.
The following snippet shows the componentType schema.
*
*
*
?
The componentType element has the following attribute:
constrainingType : QName (0..1) REF ASM40002 \h If present, the @constrainingType attribute of a element MUST reference a element in the Domain through its QName. [ASM40002] When specified, the set of services, references and properties of the implementation, plus related intents, is constrained to the set defined by the constrainingType. See HYPERLINK \l "_ConstrainingType" the ConstrainingType Section for more details.
The componentType element has the following child elements:
service : Service (0..n) HYPERLINK \l "_Service_2"see component type service section.
reference : Reference (0..n) HYPERLINK \l "_Reference" see component type reference section.
property : Property (0..n) HYPERLINK \l "_Property_1" see component type property section.
implementation : Implementation (0..1) HYPERLINK \l "_Implementation" see component type implementation section.
Service
A Service represents an addressable interface of the implementation. The service is represented by a service element which is a child of the componentType element. There can be zero or more service elements in a componentType. The following snippet shows the component type schema with the schema for a service child element:
*
*
?
+
*
*
?
The service element has the following attributes:
name : NCName (1..1) - the name of the service. REF ASM40003 \h The @name attribute of a child element of a MUST be unique amongst the service elements of that . [ASM40003]
requires : QName (0..n) - a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets : QName (0..n) - a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The service element has the following child elements:
interface : Interface (1..1) - A service has one interface, which describes the operations provided by the service. For details on the interface element see HYPERLINK \l "_Interface_1"the Interface section.
binding : Binding (0..n) - A service element has zero or more binding elements as children. If the binding element is not present it defaults to . Details of the binding element are described in HYPERLINK \l "_Binding" the Bindings section.
callback (0..1) / binding : Binding (1..n) - A service element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. If the callback element is not present, the behaviour is runtime implementation dependent. For details on callbacks, see HYPERLINK \l "_Bidirectional_Interfaces" the Bidirectional Interfaces section.
Reference
A Reference represents a requirement that the implementation has on a service provided by another component. The reference is represented by a reference element which is a child of the componentType element. There can be zero or more reference elements in a component type definition. The following snippet shows the component type schema with the schema for a reference child element:
*
*
*
?
+
*
?
The reference element has the following attributes:
name : NCName (1..1) - the name of the reference. REF ASM40004 \h The @name attribute of a child element of a MUST be unique amongst the reference elements of that . [ASM40004]
multiplicity : 0..1|1..1|0..n|1..n (0..1) - defines the number of wires that can connect the reference to target services. The multiplicity can have the following values
0..1 zero or one wire can have the reference as a source
1..1 one wire can have the reference as a source
0..n - zero or more wires can have the reference as a source
1..n one or more wires can have the reference as a source
If @multiplicity is not specified, the default value is "1..1".
target : anyURI (0..n) - a list of one or more of target service URIs, depending on multiplicity setting. Each value wires the reference to a component service that resolves the reference. For more details on wiring see HYPERLINK \l "_Wire_2" the section on Wires.
autowire : boolean (0..1) - whether the reference should be autowired, as described in HYPERLINK \l "_Autowire" the Autowire section. Default is false.
wiredByImpl : boolean (0..1) - a boolean value, "false" by default. If set to "false", the reference is wired to the target(s) configured on the reference. If set to "true" it indicates that the target of the reference is set at runtime by the implementation code (eg by the code obtaining an endpoint reference by some means and setting this as the target of the reference through the use of programming interfaces defined by the relevant Client and Implementation specification). REF ASM40006 \h If @wiredByImpl is set to "true", then any reference targets configured for this reference MUST be ignored by the runtime. [ASM40006] It is recommended that any references with @wiredByImpl = "true" are left unwired.
requires : QName (0..n) - a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets : QName (0..n) - a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The reference element has the following child elements:
interface : Interface (1..1) - A reference has one interface, which describes the operations required by the reference. The interface is described by an interface element which is a child element of the reference element. For details on the interface element see HYPERLINK \l "_Interface_1"the Interface section.
binding : Binding (0..n) - A reference element has zero or more binding elements as children. Details of the binding element are described in the HYPERLINK \l "_Binding"Bindings section.
Note that a binding element may specify an endpoint which is the target of that binding. A reference must not mix the use of endpoints specified via binding elements with target endpoints specified via the target attribute. If the target attribute is set, then binding elements can only list one or more binding types that can be used for the wires identified by the target attribute. All the binding types identified are available for use on each wire in this case. If endpoints are specified in the binding elements, each endpoint must use the binding type of the binding element in which it is defined. In addition, each binding element needs to specify an endpoint in this case.
callback (0..1) / binding : Binding (1..n) - A reference element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. If the callback element is not present, the behaviour is runtime implementation dependent. For details on callbacks, see HYPERLINK \l "_Bidirectional_Interfaces" the Bidirectional Interfaces section.
Property
Properties allow for the configuration of an implementation with externally set values. Each Property is defined as a property element. The componentType element can have zero or more property elements as its children. The following snippet shows the component type schema with the schema for a reference child element:
*
*
*
default-property-value?
?
The property element has the following attributes:
name : NCName (1..1) - the name of the property. REF ASM40005 \h The @name attribute of a child element of a MUST be unique amongst the property elements of that . [ASM40005]
one of (1..1):
type : QName - the type of the property defined as the qualified name of an XML schema type. REF ASM40007 \h The value of the property @type attribute MUST be the QName of an XML schema type. [ASM40007]
element : QName - the type of the property defined as the qualified name of an XML schema global element the type is the type of the global element. REF ASM40008 \h The value of the property @element attribute MUST be the QName of an XSD global element. [ASM40008]
many : boolean (0..1) - (optional) whether the property is single-valued (false) or multi-valued (true). In the case of a multi-valued property, it is presented to the implementation as a collection of property values.
mustSupply : boolean (0..1) - whether the property value must be supplied by the component that uses the implementation when mustSupply="true" the component must supply a value since the implementation has no default value for the property. A default-property-value should only be supplied when mustSupply="false" (the default setting for the mustSupply attribute), since the implication of a default value is that it is used only when a value is not supplied by the using component.
file : anyURI (0..1) - a dereferencable URI to a file containing a value for the property.
The value for a property is supplied to the implementation of a component at the time that the implementation is started. The implementation can choose to use the supplied value in any way that it chooses. In particular, the implementation can alter the internal value of the property at any time. However, if the implementation queries the SCA system for the value of the property, the value as defined in the SCA composite is the value returned.
The componentType property element can contain an SCA default value for the property declared by the implementation. However, the implementation can have a property which has an implementation defined default value, where the default value is not represented in the componentType. An example of such a default value is where the default value is computed at runtime by some code contained in the implementation. If a using component needs to control the value of a property used by an implementation, the component sets the value explicitly. REF ASM40009 \h The SCA runtime MUST ensure that any implementation default property value is replaced by a value for that property explicitly set by a component using that implementation. [ASM40009]
[ HYPERLINK "http://www.osoa.org/jira/browse/ASSEMBLY-38" Show ]
HYPERLINK "http://www.osoa.org/jira/secure/ViewProfile.jspa?name=scottv" Scott Vorthmann [06/May/08 01:35 AM] resolved with: The componentType property element MAY contain an SCA default value for the property declared by the implementation. However, the implementation MAY have a property which has an implementation defined default value, where the default value is not represented in the componentType. An example of such a default value is where the default value is computed at runtime by some code contained in the implementation. If a using component needs to control the value of a property used by an implementation, the component MUST set the value explicitly and the SCA runtime MUST ensure that any implementation default value is replaced.
Implementation
Implementation represents characteristics inherent to the implementation itself, in particular intents and policies. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of intents and policies. The following snippet shows the component type schema with the schema for a implementation child element:
*
*
*
?
The implementationervice element has the following attributes:
requires : QName (0..n) - a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets : QName (0..n) - a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
Example ComponentType
The following snippet shows the contents of the componentType file for the MyValueServiceImpl implementation. The componentType file shows the services, references, and properties of the MyValueServiceImpl implementation. In this case, Java is used to define interfaces:
USD
Example Implementation
The following is an example implementation, written in Java. See the HYPERLINK \l "Ref3" SCA Example Code document [3] for details.
AccountServiceImpl implements the AccountService interface, which is defined via a Java interface:
package services.account;
@Remotable
public interface AccountService {
AccountReport getAccountReport(String customerID);
}
The following is a full listing of the AccountServiceImpl class, showing the Service it implements, plus the service references it makes and the settable properties that it has. Notice the use of Java annotations to mark SCA aspects of the code, including the @Property and @Reference tags:
package services.account;
import java.util.List;
import commonj.sdo.DataFactory;
import org.osoa.sca.annotations.Property;
import org.osoa.sca.annotations.Reference;
import services.accountdata.AccountDataService;
import services.accountdata.CheckingAccount;
import services.accountdata.SavingsAccount;
import services.accountdata.StockAccount;
import services.stockquote.StockQuoteService;
public class AccountServiceImpl implements AccountService {
@Property
private String currency = "USD";
@Reference
private AccountDataService accountDataService;
@Reference
private StockQuoteService stockQuoteService;
public AccountReport getAccountReport(String customerID) {
DataFactory dataFactory = DataFactory.INSTANCE;
AccountReport accountReport = (AccountReport)dataFactory.create(AccountReport.class);
List accountSummaries = accountReport.getAccountSummaries();
CheckingAccount checkingAccount = accountDataService.getCheckingAccount(customerID);
AccountSummary checkingAccountSummary = (AccountSummary)dataFactory.create(AccountSummary.class);
checkingAccountSummary.setAccountNumber(checkingAccount.getAccountNumber());
checkingAccountSummary.setAccountType("checking");
checkingAccountSummary.setBalance(fromUSDollarToCurrency(checkingAccount.getBalance()));
accountSummaries.add(checkingAccountSummary);
SavingsAccount savingsAccount = accountDataService.getSavingsAccount(customerID);
AccountSummary savingsAccountSummary = (AccountSummary)dataFactory.create(AccountSummary.class);
savingsAccountSummary.setAccountNumber(savingsAccount.getAccountNumber());
savingsAccountSummary.setAccountType("savings");
savingsAccountSummary.setBalance(fromUSDollarToCurrency(savingsAccount.getBalance()));
accountSummaries.add(savingsAccountSummary);
StockAccount stockAccount = accountDataService.getStockAccount(customerID);
AccountSummary stockAccountSummary = (AccountSummary)dataFactory.create(AccountSummary.class);
stockAccountSummary.setAccountNumber(stockAccount.getAccountNumber());
stockAccountSummary.setAccountType("stock");
float balance= (stockQuoteService.getQuote(stockAccount.getSymbol()))*stockAccount.getQuantity();
stockAccountSummary.setBalance(fromUSDollarToCurrency(balance));
accountSummaries.add(stockAccountSummary);
return accountReport;
}
private float fromUSDollarToCurrency(float value){
if (currency.equals("USD")) return value; else
if (currency.equals("EURO")) return value * 0.8f; else
return 0.0f;
}
}
The following is the equivalent SCA componentType definition for the AccountServiceImpl, derived by reflection aginst the code above:
USD
For full details about Java implementations, see the HYPERLINK \l "Ref1" Java Client and Implementation Specification and the HYPERLINK \l "Ref3" SCA Example Code document. Other implementation types have their own specification documents.
Component
Components are the basic elements of business function in an SCA assembly, which are combined into complete business solutions by SCA composites.
Components are configured instances of implementations. Components provide and consume services. More than one component can use and configure the same implementation, where each component configures the implementation differently.
Components are declared as subelements of a composite in an xxx.composite file. A component is represented by a component element which is a child of the composite element. There can be zero or more component elements within a composite. The following snippet shows the composite schema with the schema for the component child element.
*
?
*
*
*
The component element has the following attributes:
name : NCName (1..1) the name of the component. REF ASM50001 \h The @name attribute of a child element of a MUST be unique amongst the service elements of that . [ASM50001]
autowire : boolean (0..1) whether contained component references should be autowired, as described in HYPERLINK \l "_Autowire" the Autowire section. Default is false.
requires : QName (0..n) a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
constrainingType : QName (0..1) the name of a constrainingType. When specified, the set of services, references and properties of the component, plus related intents, is constrained to the set defined by the constrainingType. See HYPERLINK \l "_ConstrainingType" the ConstrainingType Section for more details.
The component element has the following child elements:
implementation : ComponentImplementation (0..1) HYPERLINK \l "_Implementation_" see component implementation section.
service : ComponentService (0..n) HYPERLINK \l "_Service_1" see component service section.
reference : ComponentReference (0..n) HYPERLINK \l "_Reference_" see component reference section.
property : ComponentProperty (0..n) HYPERLINK \l "_Property_" see component property section.
Implementation
A component element has zero or one implementation element as its child, which points to the implementation used by the component. A component with no implementation element is not runnable, but components of this kind may be useful during a "top-down" development process as a means of defining the characteristics required of the implementation before the implementation is written.
*
?
*
*
*
The component provides the extensibility point in the assembly model for different implementation types. The references to implementations of different types are expressed by implementation type specific implementation elements.
For example the elements implementation.java, implementation.bpel, implementation.cpp, and implementation.c point to Java, BPEL, C++, and C implementation types respectively. implementation.composite points to the use of an SCA composite as an implementation. implementation.spring and implementation.ejb are used for Java components written to the Spring framework and the Java EE EJB technology respectively.
The following snippets show implementation elements for the Java and BPEL implementation types and for the use of a composite as an implementation:
New implementation types can be added to the model as described in the Extension Model section.
At runtime, an implementation instance is a specific runtime instantiation of the implementation its runtime form depends on the implementation technology used. The implementation instance derives its business logic from the implementation on which it is based, but the values for its properties and references are derived from the component which configures the implementation.
Figure SEQ Figure \* ARABIC 4: Relationship of Component and Implementation
Service
The component element can have zero or more service elements as children which are used to configure the services of the component. The services that can be configured are defined by the implementation. The following snippet shows the component schema with the schema for a service child element:
*
?
*
?
*
?
+
*
*
The component service element has the following attributes:
name : NCName (1..1) - the name of the service. REF ASM50002 \h The @name attribute of a service element of a MUST be unique amongst the service elements of that [ASM50002] REF ASM50003 \h The @name attribute of a service element of a MUST match the @name attribute of a service element of the componentType of the child element of the component. [ASM50003]
requires : QName (0..n) a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute. Note: The effective set of policy intents for the service consists of any intents explicitly stated in this requires attribute, combined with any intents specified for the service by the implementation.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The component service element has the following child elements:
interface : Interface (0..1) - A service has zero or one interface, which describes the operations provided by the service. The interface is described by an interface element which is a child element of the service element. If no interface is specified, then the interface specified for the service in the componentType of the implementation is in effect. REF ASM50004 \h If a element has an interface subelement specified, the interface MUST provide a compatible subset of the interface declared on the componentType of the implementation [ASM50004] For details on the interface element see HYPERLINK \l "_Interface_1"the Interface section.
binding : Binding (0..n) - A service element has zero or more binding elements as children. REF ASM50005 \h If no binding elements are specified for the service, then the bindings specified for the equivalent service in the componentType of the implementation MUST be used, but if the componentType also has no bindings specified, then MUST be used as the binding. If binding elements are specified for the service, then those bindings MUST be used and they override any bindings specified for the equivalent service in the componentType of the implementation. [ASM50005] Details of the binding element are described in HYPERLINK \l "_Binding" the Bindings section. The binding, combined with any PolicySets in effect for the binding, needs to satisfy the set of policy intents for the service, as described in HYPERLINK \l "Ref10" the Policy Framework specification [10].
callback (0..1) / binding : Binding (1..n) - A service element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. REF ASM50006 \h If the callback element is present and contains one or more binding child elements, then those bindings MUST be used for the callback. [ASM50006] If the callback element is not present, the behaviour is runtime implementation dependent.
Reference
The component element can have zero or more reference elements as children which are used to configure the references of the component. The references that can be configured are defined by the implementation. The following snippet shows the component schema with the schema for a reference child element:
*
?
*
*
?
*
?
+
*
The component reference element has the following attributes:
name : NCName (1..1) the name of the reference. REF ASM50007 \h The @name attribute of a service element of a MUST be unique amongst the service elements of that [ASM50007] REF ASM50008 \h The @name attribute of a reference element of a MUST match the @name attribute of a reference element of the componentType of the child element of the component. [ASM50008]
autowire : boolean (0..1) whether the reference should be autowired, as described in HYPERLINK \l "_Autowire" the Autowire section. Default is false.
requires : QName (0..n) a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.Note: The effective set of policy intents for the reference consists of any intents explicitly stated in this requires attribute, combined with any intents specified for the reference by the implementation.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
multiplicity : 0..1|1..1|0..n|1..n (0..1) - defines the number of wires that can connect the reference to target services. Overrides the multiplicity specified for this reference in the componentType of the implementation. The multiplicity can have the following values
0..1 zero or one wire can have the reference as a source
1..1 one wire can have the reference as a source
0..n - zero or more wires can have the reference as a source
1..n one or more wires can have the reference as a source
REF ASM50009 \h The value of multiplicity for a component reference MUST only be equal or further restrict any value for the multiplicity of the reference with the same name in the componentType of the implementation, where further restriction means 0..n to 0..1 or 1..n to 1..1. [ASM50009]
If not present, the value of multiplicity is equal to the multiplicity specificed for this reference in the componentType of the implementation - if not present in the componentType, the value defaults to 1..1.
target : anyURI (0..n) a list of one or more of target service URIs, depending on multiplicity setting. Each value wires the reference to a component service that resolves the reference. For more details on wiring see HYPERLINK \l "_Wire_2" the section on Wires. Overrides any target specified for this reference on the implementation.
wiredByImpl : boolean (0..1) a boolean value, "false" by default, which indicates that the implementation wires this reference dynamically. If set to "true" it indicates that the target of the reference is set at runtime by the implementation code (eg by the code obtaining an endpoint reference by some means and setting this as the target of the reference through the use of programming interfaces defined by the relevant Client and Implementation specification). REF ASM50010 \h If @wiredByImpl="true" is set for a reference, then the reference MUST NOT be wired statically within a composite, but left unwired. [ASM50010]
The component reference element has the following child elements:
interface : Interface (0..1) - A reference has zero or one interface, which describes the operations required by the reference. The interface is described by an interface element which is a child element of the reference element. If no interface is specified, then the interface specified for the reference in the componentType of the implementation is in effect. REF ASM50011 \h If an interface is declared for a component reference it MUST provide a compatible superset of the interface declared for the equivalent reference in the componentType of the implementation, i.e. provide the same operations or a superset of the operations defined by the implementation for the reference. [ASM50011] For details on the interface element see HYPERLINK \l "_Interface_1"the Interface section.
binding : Binding (0..n) - A reference element has zero or more binding elements as children. REF ASM50012 \h If no binding elements are specified for the reference, then the bindings specified for the equivalent reference in the componentType of the implementation MUST be used, but if the componentType also has no bindings specified, then MUST be used as the binding. If binding elements are specified for the reference, then those bindings MUST be used and they override any bindings specified for the equivalent reference in the componentType of the implementation. [ASM50012] Details of the binding element are described in the HYPERLINK \l "_Binding"Bindings section. The binding, combined with any PolicySets in effect for the binding, needs to satisfy the set of policy intents for the reference, as described in HYPERLINK \l "Ref10" the Policy Framework specification [10].
A reference identifies zero or more target services that satisfy the reference. This can be done in a number of ways, which are fully described in section "5.3.1 Specifying the Target Service(s) for a Reference"
callback (0..1) / binding : Binding (1..n) - A reference element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. REF ASM50006 \h If the callback element is present and contains one or more binding child elements, then those bindings MUST be used for the callback. [ASM50006] If the callback element is not present, the behaviour is runtime implementation dependent.
Specifying the Target Service(s) for a Reference
A reference defines zero or more target services that satisfy the reference. The target service(s) can be defined in the following ways:
Through a value specified in the @target attribute of the reference element
Through a target URI specified in the @uri attribute of a binding element which is a child of the reference element
Through the setting of one or more values for binding-specific attributes and/or child elements of a binding element that is a child of the reference element
Through the specification of @autowire="true" for the reference (or through inheritance of that value from the component or composite containing the reference)
Through the specification of @wiredByImpl="true" for the reference
Through the promotion of a component reference by a composite reference of the composite containing the component (the target service is then identified by the configuration of the composite reference)
Combinations of these different methods are allowed, and the following rules MUST be observed:
REF ASM50013 \h If @wiredByImpl="true", other methods of specifying the target service MUST NOT be used. [ASM50013]
REF ASM50014 \h If @autowire="true", the autowire procedure MUST only be used if no target is identified by any of the other ways listed above. It is not an error if @autowire="true" and a target is also defined through some other means, however in this case the autowire procedure MUST NOT be used. [ASM50014]
REF ASM50026 \h If a reference has a value specified for one or more target services in its @target attribute, the child binding elements of that reference MUST NOT identify target services using the @uri attribute or using binding specific attributes or elements. [ASM50026]
REF ASM50015 \h If a binding element has a value specified for a target service using its @uri attribute, the binding element MUST NOT identify target services using binding specific attributes or elements. [ASM50015]
REF ASM50016 \h It is possible that a particular binding type MAY require that the address of a target service uses more than a simple URI. In such cases, the @uri attribute MUST NOT be used to identify the target service - instead, binding specific attributes and/or child elements must be used. [ASM50016]
REF ASM50017 \h When the reference has a value specified in its @target attribute, one of the child binding elements MUST be used on each wire created by the @target attribute, or the sca binding, if no binding is specified. [ASM50017]
Multiplicity and the Valid Number of Target Services for a Reference
The number of target services configured for a reference are constrained by the following rules.
REF ASM50018 \h A reference with multiplicity 0..1 or 0..n MAY have no target service defined. [ASM50018]
REF ASM50019 \h A reference with multiplicity 0..1 or 1..1 MUST NOT have more that one target service defined. [ASM50019]
REF ASM50020 \h A reference with multiplicity 1..1 or 1..n MUST have at least one target service defined. [ASM50020]
REF ASM50021 \h A reference with multiplicity 0..n or 1..n MAY have one or more target services defined. [ASM50021]
REF ASM50022 \h Where it is detected that the rules for the number of target services for a reference have been violated, either at deployment or at execution time, an SCA Runtime MUST generate an error no later than when the reference is invoked by the component implementation. [ASM50022]
REF ASM50023 \h Some reference multiplicity errors can be detected at deployment time. In these cases, an error SHOULD be generated by the SCA runtime at deployment time. [ASM50023] For example, where a composite is used as a component implementation, wires and target services cannot be added to the composite after deployment. As a result, for components which are part of the composite, both missing wires and wires with a non-existent target can be detected at deployment time through a scan of the contents of the composite.
REF ASM50024 \h Other reference multiplicity errors can only be checked at runtime. In these cases, the SCA runtime MUST generate an error no later than when the reference is invoked by the component implementation. [ASM50024] Examples include cases of components deployed to the SCA Domain. At the Domain level, the target of a wire, or even the wire itself, may form part of a separate deployed contribution and as a result these may be deployed after the original component is deployed. For the cases where it is valid for the reference to have no target service specified, the component implementation language specification needs to define the programming model for interacting with an untargetted reference.
REF ASM50025 \h Where a component reference is promoted by a composite reference, the promotion MUST be treated from a multiplicity perspective as providing 0 or more target services for the component reference, depending upon the further configuration of the composite reference. These target services are in addition to any target services identified on the component reference itself, subject to the rules relating to multiplicity. [ASM50025]
Property
The component element has zero or more property elements as its children, which are used to configure data values of properties of the implementation. Each property element provides a value for the named property, which is passed to the implementation. The properties that can be configured and their types are defined by the component type of the implementation. An implementation can declare a property as multi-valued, in which case, multiple property values can be present for a given property.
The property value can be specified in one of five ways:
As a value, supplied in the value attribute of the property element. REF ASM50027 \h If the @value attribute of a component property element is declared, the type of the property MUST be an XML Schema simple type and the @value attribute MUST contain a single value of that type. [ASM50027]
For example,
As a value, supplied as the content of the value element(s) children of the property element. REF ASM50028 \h If the value subelement of a component property is specified, the type of the property MUST be an XML Schema simple type or an XML schema complex type. [ASM50028]
For example,
property defined using a XML Schema simple type and which contains a single value
3.14159265
property defined using a XML Schema simple type and which contains multiple values
EUROUSDollar
property defined using a XML Schema complex type and which contains a single value
TheValueInterestingURI
property defined using a XML Schema complex type and which contains multiple values
AValueInterestingURIBValueBoringURI
As a value, supplied as the content of the property element. REF ASM50029 \h If a component property value is declared using a child element of the element, the type of the property MUST be an XML Schema global element and the declared child element MUST be an instance of that global element. [ASM50029]
For example,
property defined using a XML Schema global element declartion and which contains a single value
...
property defined using a XML Schema global element declaration and which contains multiple values
......
By referencing a Property value of the composite which contains the component. The reference is made using the source attribute of the property element. The form of the value of the source attribute follows the form of an XPath expression. This form allows a specific property of the composite to be addressed by name. Where the composite property is of a complex type, the XPath expression can be extended to refer to a sub-part of the complex property value.So, for example, source="$currency" is used to reference a property of the composite called "currency", while source="$currency/a" references the sub-part "a" of the complex composite property with the name "currency".Note that the source attribute refers to the contents of the composite after the processing of all elements, so that it is possible for @source to refer to a composite property that is not contained in the same physical file as the component property element, as long as the composite property and the component are brought together through include processing.
By specifying a dereferencable URI to a file containing the property value through the file attribute. The contents of the referenced file are used as the value of the property.
If more than one property value specification is present, the source attribute takes precedence, then the file attribute.
For a property defined using a XML Schema simple type and for which a single value is desired, can be set either using the @value attribute or the child element. The two forms in such a case are equivalent.
When a property has multiple values set, they MUST all be contained within the same property element. REF ASM50030 \h A element MUST NOT contain two subelements with the same value of the @name attribute. [ASM50030]
Optionally, the type of the property can be specified in one of two ways:
by the qualified name of a type defined in an XML schema, using the type attribute
by the qualified name of a global element in an XML schema, using the element attribute
The property type specified must be compatible with the type of the property declared in the component type of the implementation. If no type is declared in the component property, the type of the property declared by the implementation is used.
The following snippet shows the component schema with the schema for a property child element:
*
?
*
*
*
[+ | xs:any+ ]?
The component property element has the following attributes:
name : NCName (1..1) the name of the property. REF ASM50031 \h The name attribute of a component property MUST match the name of a property element in the component type of the component implementation. [ASM50031]
zero or one of (0..1):
type : QName the type of the property defined as the qualified name of an XML schema type
element : QName the type of the property defined as the qualified name of an XML schema global element the type is the type of the global element
source : string (0..1) an XPath expression pointing to a property of the containing composite (post include processing) from which the value of this component property is obtained.
file : anyURI (0..1) a dereferencable URI to a file containing a value for the property
many : boolean (0..1) (optional) whether the property is single-valued (false) or multi-valued (true). Overrides the many specified for this property on the implementation. The value can only be equal or further restrict, i.e. if the implementation specifies many true, then the component can say false. In the case of a multi-valued property, it is presented to the implementation as a Collection of property values.
value : string (0..1) - the value of the property if the property is defined using a simple type.
The component property element has the following child element:
value :any (0..n) - A property has zero or more, value elements that specify the value(s) of a property that is defined using a XML Schema type. REF ASM50032 \h If a property is single-valued, the subelement MUST NOT occur more than once. [ASM50032] REF ASM50033 \h A property subelement MUST NOT be used when the @value attribute is used to specify the value for that property. [ASM50033]
Example Component
The following figure shows the component symbol that is used to represent a component in an assembly diagram.
Figure SEQ Figure \* ARABIC 5: Component symbol
The following figure shows the assembly diagram for the MyValueComposite containing the MyValueServiceComponent.
Figure SEQ Figure \* ARABIC 6: Assembly diagram for MyValueComposite
The following snippet shows the MyValueComposite.composite file for the MyValueComposite containing the component element for the MyValueServiceComponent. A value is set for the property named currency, and the customerService and stockQuoteService references are promoted:
EURO
Note that the references of MyValueServiceComponent are explicitly declared only for purposes of clarity the references are defined by the MyValueServiceImpl implementation and there is no need to redeclare them on the component unless the intention is to wire them or to override some aspect of them.
The following snippet gives an example of the layout of a composite file if both the currency property and the customerService reference of the MyValueServiceComponent are declared to be multi-valued (many=true for the property and multiplicity=0..n or 1..n for the reference):
EUROYenUSDollar
...
.this assumes that the composite has another component called InternalCustomer (not shown) which has a service to which the customerService reference of the MyValueServiceComponent is wired as well as being promoted externally through the composite reference CustomerService.
Composite
An SCA composite is used to assemble SCA elements in logical groupings. It is the basic unit of composition within an SCA Domain. An SCA composite contains a set of components, services, references and the wires that interconnect them, plus a set of properties which can be used to configure components.
Composites can be used as component implementations in higher-level composites in other words the higher-level composites can have components that are implemented by composites. For more detail on the use of composites as component implementations see the section HYPERLINK \l "_Using_Composites_as" Using Composites as Component Implementations.
The content of a composite can be used within another composite through inclusion. When a composite is included by another composite, all of its contents are made available for use within the including composite the contents are fully visible and can be referenced by other elements within the including composite. For more detail on the inclusion of one composite into another see the section HYPERLINK \l "_Using_Composites_through" Using Composites through Inclusion.
A composite can be used as a unit of deployment. When used in this way, composites contribute elements to an SCA domain. A composite can be deployed to the SCA domain either by inclusion, or a composite can be deployed to the domain as an implementation. For more detail on the deployment of composites, see the section dealing with the HYPERLINK \l "_System" SCA Domain.
A composite is defined in an xxx.composite file. A composite is represented by a composite element. The following snippet shows the schema for the composite element.
*
*
*
*
*
*
The composite element has the following attributes:
name : NCName (1..1) the name of the composite. The form of a composite name is an XML QName, in the namespace identified by the targetNamespace attribute. REF ASM60001 \h A composite name must be unique within the namespace of the composite. [ASM60001]
targetNamespace : anyURI (0..1) an identifier for a target namespace into which the composite is declared
local : boolean (0..1) whether all the components within the composite all run in the same operating system process. REF ASM60002 \h @local="true" for a composite means that all the components within the composite MUST run in the same operating system process. [ASM60002] local="false", which is the default, means that different components within the composite can run in different operating system processes and they can even run on different nodes on a network.
autowire : boolean (0..1) whether contained component references should be autowired, as described in HYPERLINK \l "_Autowire" the Autowire section. Default is false.
constrainingType : QName (0..1) the name of a constrainingType. When specified, the set of services, references and properties of the composite, plus related intents, is constrained to the set defined by the constrainingType. See HYPERLINK \l "_ConstrainingType" the ConstrainingType Section for more details.
requires : QName (0..n) a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The composite element has the following child elements:
service : CompositeService (0..n) see composite service section.
reference : CompositeReference (0..n) see composite reference section.
property : CompositeProperty (0..n) see composite property section.
component : Component (0..n) see component section.
wire : Wire (0..n) see composite wire section.
include : Include (0..n) see composite include section
Components contain configured implementations which hold the business logic of the composite. The components offer services and require references to other services. Composite services define the public services provided by the composite, which can be accessed from outside the composite. Composite references represent dependencies which the composite has on services provided elsewhere, outside the composite. Wires describe the connections between component services and component references within the composite. Included composites contribute the elements they contain to the using composite.
Composite services involve the promotion of one service of one of the components within the composite, which means that the composite service is actually provided by one of the components within the composite. Composite references involve the promotion of one or more references of one or more components. Multiple component references can be promoted to the same composite reference, as long as all the component references are compatible with one another. Where multiple component references are promoted to the same composite reference, then they all share the same configuration, including the same target service(s).
Composite services and composite references can use the configuration of their promoted services and references respectively (such as Bindings and Policy Sets). Alternatively composite services and composite references can override some or all of the configuration of the promoted services and references, through the configuration of bindings and other aspects of the composite service or reference.
Component services and component references can be promoted to composite services and references and also be wired internally within the composite at the same time. For a reference, this only makes sense if the reference supports a multiplicity greater than 1.
Service
The services of a composite are defined by promoting services defined by components contained in the composite. A component service is promoted by means of a composite service element.
A composite service is represented by a service element which is a child of the composite element. There can be zero or more service elements in a composite. The following snippet shows the composite schema with the schema for a service child element:
*
?
*
?
+
The composite service element has the following attributes:
name : NCName (1..1) the name of the service. REF ASM60003 \h The name of a composite element MUST be unique across all the composite services in the composite. [ASM60003] The name of the composite service can be different from the name of the promoted component service.
promote : anyURI (1..1) identifies the promoted service, the value is of the form /. The service name is optional if the target component only has one service. The same component service can be promoted by more then one composite service. REF ASM60004 \h A composite element's promote attribute MUST identify one of the component services within that composite. [ASM60004] Note that the promote attribute refers to the contents of the composite after the processing of all elements, so that it is possible for @promote to refer to a component that is not contained in the same physical file as the composite service element, as long as the composite service and the referenced component are brought together through include processing.
requires : QName (0..n) a list of required policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute. Specified required intents add to or further qualify the required intents defined by the promoted component service.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The composite service element has the following child elements, whatever is not specified is defaulted from the promoted component service.
interface : Interface (0..1) - REF ASM60005 \h If a composite service interface is specified it must be the same or a compatible subset of the interface provided by the promoted component service, i.e. provide a subset of the operations defined by the component service. [ASM60005] The interface is described by zero or one interface element which is a child element of the service element. For details on the interface element see HYPERLINK \l "_Interface" the Interface section.
binding : Binding (0..n) - If bindings are specified they override the bindings defined for the promoted component service from the composite service perspective. The bindings defined on the component service are still in effect for local wires within the composite that target the component service. A service element has zero or more binding elements as children. Details of the binding element are described in the HYPERLINK \l "_Binding" Bindings section. For more details on wiring see HYPERLINK \l "_Wire_1" the Wiring section.
callback (0..1) / binding : Binding (1..n) - A service element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. If the callback element is not present, the behaviour is runtime implementation dependent.
Service Examples
The following figure shows the service symbol that used to represent a service in an assembly diagram:
Figure SEQ Figure \* ARABIC 7: Service symbol
The following figure shows the assembly diagram for the MyValueComposite containing the service MyValueService.
Figure SEQ Figure \* ARABIC 8: MyValueComposite showing Service
The following snippet shows the MyValueComposite.composite file for the MyValueComposite containing the service element for the MyValueService, which is a promote of the service offered by the MyValueServiceComponent. The name of the promoted service is omitted since MyValueServiceComponent offers only one service. The composite service MyValueService is bound using a Web service binding.
...
EURO
...
Reference
The references of a composite are defined by promoting references defined by components contained in the composite. Each promoted reference indicates that the component reference needs to be resolved by services outside the composite. A component reference is promoted using a composite reference element.
A composite reference is represented by a reference element which is a child of a composite element. There can be zero or more reference elements in a composite. The following snippet shows the composite schema with the schema for a reference element.
*
?
*
?
+
The composite reference element has the following attributes:
name : NCName (1..1) the name of the reference. REF ASM60006 \h The name of a composite element MUST be unique across all the composite references in the composite. [ASM60006] The name of the composite reference can be different then the name of the promoted component reference.
promote : anyURI (1..n) identifies one or more promoted component references. The value is a list of values of the form / separated by spaces. The specification of the reference name is optional if the component has only one reference. REF ASM60007 \h Each of the URIs declared by a composite reference's @promote attribute MUST identify a component reference within the composite. [ASM60007] Note that the promote attribute refers to the contents of the composite after the processing of all elements, so that it is possible for @promote to refer to a component that is not contained in the same physical file as the composite reference element, as long as the composite reference and the referenced component are brought together through include processing.
The same component reference can be promoted more than once, using different composite references, but only if the multiplicity defined on the component reference is 0..n or 1..n. The multiplicity on the composite reference can restrict accordingly.
Where a composite reference promotes two or more component references:
REF ASM60008 \h the interfaces of the component references promoted by a composite reference MUST be the same, or if the composite reference itself declares an interface then all the component reference interfaces must be compatible with the composite reference interface. Compatible means that the component reference interface is the same or is a strict subset of the composite reference interface. [ASM60008]
REF ASM60009 \h the intents declared on a composite reference and on the component references which it promoites MUST NOT be mutually exclusive. [ASM60009] The intents which apply to the composite reference in this case are the union of the required intents specified for each of the promoted component references plus any intents declared on the composite reference itself. REF ASM60010 \h If any intents in the set which apply to a composite reference are mutually exclusive then the SCA runtime MUST raise an error. [ASM60010]
requires : QName (0..n) a list of required policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute. Specified required intents add to or further qualify the required intents defined for the promoted component reference.
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
multiplicity : 0..1|1..1|0..n|1..n (1..1) - Defines the number of wires that can connect the reference to target services. The multiplicity can have the following values
0..1 zero or one wire can have the reference as a source
1..1 one wire can have the reference as a source
0..n - zero or more wires can have the reference as a source
1..n one or more wires can have the reference as a source
REF ASM60011 \h The value specified for the multiplicity attribute of a composite reference MUST be compatible with the multiplicity specified on each of the promoted component references, i.e. the multiplicity has to be equal or further restrict. So multiplicity 0..1 can be used where the promoted component reference has multiplicity 0..n, multiplicity 1..1 can be used where the promoted component reference has multiplicity 0..n or 1..n and multiplicity 1..n can be used where the promoted component reference has multiplicity 0..n., However, a composite reference of multiplicity 0..n or 1..n cannot be used to promote a component reference of multiplicity 0..1 or 1..1 respectively. [ASM60011]
target : anyURI (0..n) a list of one or more of target service URIs, depending on multiplicity setting. Each value wires the reference to a service in a composite that uses the composite containg the reference as an implementation for one of its components. For more details on wiring see HYPERLINK \l "_Wire_2" the section on Wires.
wiredByImpl : boolean (0..1) a boolean value, "false" by default, which indicates that the implementation wires this reference dynamically. If set to "true" it indicates that the target of the reference is set at runtime by the implementation code (eg by the code obtaining an endpoint reference by some means and setting this as the target of the reference through the use of programming interfaces defined by the relevant Client and Implementation specification). If "true" is set, then the reference should not be wired statically within a using composite, but left unwired.
The composite reference element has the following child elements, whatever is not specified is defaulted from the promoted component reference(s).
interface : Interface (0..1) - zero or one interface element which declares an interface for the composite reference. REF ASM60012 \h If a composite reference has an interface specified, it MUST provide an interface which is the same or which is a compatible superset of the interface(s) declared by the promoted component reference(s), i.e. provide a superset of the operations in the interface defined by the component for the reference. [ASM60012] REF ASM60013 \h If no interface is declared on a composite reference, the interface from one of its promoted component references is used, which MUST be the same as or a compatible superset of the interface(s) declared by the promoted component reference(s).[ASM60013] For details on the interface element see HYPERLINK \l "_Interface" the Interface section.
binding : Binding (0..n) - A reference element has zero or more binding elements as children. If one or more bindings are specified they override any and all of the bindings defined for the promoted component reference from the composite reference perspective. The bindings defined on the component reference are still in effect for local wires within the composite that have the component reference as their source. Details of the binding element are described in the HYPERLINK \l "_Binding"Bindings section. For more details on wiring see HYPERLINK \l "_Wire_2" the section on Wires.
A reference identifies zero or more target services which satisfy the reference. This can be done in a number of ways, which are fully described in section " HYPERLINK \l "_Specifying_the_Target" 5.3.1 Specifying the Target Service(s) for a Reference".
callback (0..1) / binding : Binding (1..n) - A reference element has an optional callback element used if the interface has a callback defined, which has one or more binding elements as children. The callback and its binding child elements are specified if there is a need to have binding details used to handle callbacks. If the callback element is not present, the behaviour is runtime implementation dependent.
Example Reference
The following figure shows the reference symbol that is used to represent a reference in an assembly diagram.
Figure SEQ Figure \* ARABIC 9: Reference symbol
The following figure shows the assembly diagram for the MyValueComposite containing the reference CustomerService and the reference StockQuoteService.
Figure SEQ Figure \* ARABIC 10: MyValueComposite showing References
The following snippet shows the MyValueComposite.composite file for the MyValueComposite containing the reference elements for the CustomerService and the StockQuoteService. The reference CustomerService is bound using the SCA binding. The reference StockQuoteService is bound using the Web service binding. The endpoint addresses of the bindings can be specified, for example using the binding uri attribute (for details see the HYPERLINK \l "_Binding" Bindings section), or overridden in an enclosing composite. Although in this case the reference StockQuoteService is bound to a Web service, its interface is defined by a Java interface, which was created from the WSDL portType of the target web service.
...
EURO
...
Property
Properties allow for the configuration of an implementation with externally set data values. A composite can declare zero or more properties. Each property has a type, which may be either simple or complex. An implementation can also define a default value for a property. Properties can be configured with values in the components that use the implementation.
The declaration of a property in a composite follows the form described in the following schema snippet:
*
default-property-value?
The composite property element has the following attributes:
name : NCName (1..1) - the name of the property. REF ASM60014 \h The name attribute of a composite property MUST be unique amongst the properties of the same composite. [ASM60014]
one of (1..1):
type : QName the type of the property - the qualified name of an XML schema type
element : QName the type of the property defined as the qualified name of an XML schema global element the type is the type of the global element
many : boolean (0..1) - whether the property is single-valued (false) or multi-valued (true). The default is false. In the case of a multi-valued property, it is presented to the implementation as a collection of property values.
mustSupply : boolean (0..1) whether the property value has to be supplied by the component that uses the composite when mustSupply="true" the component has to supply a value since the composite has no default value for the property. A default-property-value is only worth declaring when mustSupply="false" (the default setting for the mustSupply attribute), since the implication of a default value is that it is used only when a value is not supplied by the using component.
The property element may contain an optional default-property-value, which provides default value for the property. The default value must match the type declared for the property:
a string, if type is a simple type (matching the type declared)
a complex type value matching the type declared by type
an element matching the element named by element
multiple values are permitted if many="true" is specified
Implementation types other than composite can declare properties in an implementation-dependent form (eg annotations within a Java class), or through a property declaration of exactly the form described above in a componentType file.
Property values can be configured when an implementation is used by a component. The form of the property configuration is shown in HYPERLINK \l "_Component" the section on Components.
Property Examples
For the following example of Property declaration and value setting, the following complex type is used as an example:
The following composite demostrates the declaration of a property of a complex type, with a default value, plus it demonstrates the setting of a property value of a complex type within a component:
...
AValueInterestingURI
...
In the declaration of the property named complexFoo in the composite AccountServices, the property is defined to be of type foo:MyComplexType. The namespace foo is declared in the composite and it references the example XSD, where MyComplexType is defined. The declaration of complexFoo contains a default value. This is declared as the content of the property element. In this example, the default value consists of the element MyComplexPropertyValue of type foo:MyComplexType and its two child elements and , following the definition of MyComplexType.
In the component AccountServiceComponent, the component sets the value of the property complexBar, declared by the implementation configured by the component. In this case, the type of complexBar is foo:MyComplexType. The example shows that the value of the complexBar property is set from the value of the complexFoo property the source attribute of the property element for complexBar declares that the value of the property is set from the value of a property of the containing composite. The value of the source attribute is $complexFoo, where complexFoo is the name of a property of the composite. This value implies that the whole of the value of the source property is used to set the value of the component property.
The following example illustrates the setting of the value of a property of a simple type (a string) from part of the value of a property of the containing composite which has a complex type:
...
AValueInterestingURI
...
In this example, the component AccountServiceComponent sets the value of a property called currency, which is of type string. The value is set from a property of the composite AccountServices using the source attribute set to $complexFoo/a. This is an XPath expression that selects the property name complexFoo and then selects the value of the a subelement of complexFoo. The "a" subelement is a string, matching the type of the currency property.
Further examples of declaring properties and setting property values in a component follow:
Declaration of a property with a simple type and a default value:
MyValue
Declaration of a property with a complex type and a default value:
AValueInterestingURI
Declaration of a property with an element type:
AValueInterestingURI
Property value for a simple type:
MyValue
Property value for a complex type, also showing the setting of an attribute value of the complex type:
AValueInterestingURI
Property value for an element type:
AValueInterestingURI
Declaration of a property with a complex type where multiple values are supported:
Setting of a value for that property where multiple values are supplied:
AValueInterestingURIBValueBoringURI
Wire
SCA wires within a composite connect source component references to target component services.
One way of defining a wire is by configuring a reference of a component using its target attribute. The reference element is configured with the wire-target-URI of the service(s) that resolve the reference. Multiple target services are valid when the reference has a multiplicity of 0..n or 1..n.
An alternative way of defining a Wire is by means of a wire element which is a child of the composite element. There can be zero or more wire elements in a composite. This alternative method for defining wires is useful in circumstances where separation of the wiring from the elements the wires connect helps simplify development or operational activities. An example is where the components used to build a domain are relatively static but where new or changed applications are created regularly from those components, through the creation of new assemblies with different wiring. Deploying the wiring separately from the components allows the wiring to be created or modified with minimum effort.
Note that a Wire specified via a wire element is equivalent to a wire specified via the target attribute of a reference. The rule which forbids mixing of wires specified with the target attribute with the specification of endpoints in binding subelements of the reference also applies to wires specified via separate wire elements.
The following snippet shows the composite schema with the schema for the reference elements of components and composite services and the wire child element:
...
*
The reference element of a component and the reference element of a service has a list of one or more of the following wire-target-URI values for the target, with multiple values separated by a space:
/
where the target is a service of a component. The specification of the service name is optional if the target component only has one service with a compatible interface
The wire element has the following attributes:
source (1..1) names the source component reference. Valid URI schemes are:
/
where the source is a component reference. The specification of the reference name is optional if the source component only has one reference
target (1..1) names the target component service. Valid URI schemes are
/
where the target is a service of a component. The specification of the service name is optional if the target component only has one service with a compatible interface
For a composite used as a component implementation, wires can only link sources and targets that are contained in the same composite (irrespective of which file or files are used to describe the composite). Wiring to entities outside the composite is done through services and references of the composite with wiring defined by the next higher composite.
Note that the source and target attributes refer to the contents of the composite after the processing of all elements, so that it is possible for these attributes to refer to a component that is not contained in the same physical file as the wire element, as long as the wire and the referenced component(s) are brought together through include processing.
A wire may only connect a source to a target if the target implements an interface that is compatible with the interface required by the source. The source and the target are compatible if:
REF ASM60015 \h the source interface and the target interface of a wire MUST either both be remotable or else both be local [ASM60015]
REF ASM60016 \h the operations on the target interface of a wire MUST be the same as or be a superset of the operations in the interface specified on the source [ASM60016]
REF ASM60017 \h compatibility between the source interface and the target interface for a wire for the individual operations is defined as compatibility of the signature, that is operation name, input types, and output types MUST be the same. [ASM60017]
REF ASM60018 \h the order of the input and output types for operations in the source interface and the target interface of a wire also MUST be the same. [ASM60018]
REF ASM60019 \h the set of Faults and Exceptions expected by each operation in the source interface MUST be the same or be a superset of those specified by the target interface. [ASM60019]
REF ASM60020 \h other specified attributes of the source interface and the target interface of a wire MUST match, including Scope and Callback interface [ASM60020]
A Wire can connect between different interface languages (eg. Java interfaces and WSDL portTypes) in either direction, as long as the operations defined by the two interface types are equivalent. They are equivalent if the operation(s), parameter(s), return value(s) and faults/exceptions map to each other.
Service clients cannot (portably) ask questions at runtime about additional interfaces that are provided by the implementation of the service (e.g. the result of instance of in Java is non portable). It is valid for an SCA implementation to have proxies for all wires, so that, for example, a reference object passed to an implementation may only have the business interface of the reference and may not be an instance of the (Java) class which is used to implement the target service, even where the interface is local and the target service is running in the same process.
Note: It is permitted to deploy a composite that has references that are not wired. REF ASM60021 \h For the case of an un-wired reference with multiplicity 1..1 or 1..n the deployment process provided by an SCA runtime SHOULD issue a warning. [ASM60021]
Wire Examples
The following figure shows the assembly diagram for the MyValueComposite2 containing wires between service, components and references.
Figure SEQ Figure \* ARABIC 11: MyValueComposite2 showing Wires
The following snippet shows the MyValueComposite2.composite file for the MyValueComposite2 containing the configured component and service references. The service MyValueService is wired to the MyValueServiceComponent, using an explicit element. The MyValueServiceComponents customerService reference is wired to the composite's CustomerService reference. The MyValueServiceComponents stockQuoteService reference is wired to the StockQuoteMediatorComponent, which in turn has its reference wired to the StockQuoteService reference of the composite.
EUROEURO
Autowire
SCA provides a feature named Autowire, which can help to simplify the assembly of composites. Autowire enables component references to be automatically wired to component services which will satisfy those references, without the need to create explicit wires between the references and the services. When the autowire feature is used, a component reference which is not promoted and which is not explicitly wired to a service within a composite is automatically wired to a target service within the same composite. Autowire works by searching within the composite for a service interface which matches the interface of the references.
The autowire feature is not used by default. Autowire is enabled by the setting of an autowire attribute to "true". Autowire is disabled by setting of the autowire attribute to "false" The autowire attribute can be applied to any of the following elements within a composite:
reference
component
composite
Where an element does not have an explicit setting for the autowire attribute, it inherits the setting from its parent element. Thus a reference element inherits the setting from its containing component. A component element inherits the setting from its containing composite. Where there is no setting on any level, autowire="false" is the default.
As an example, if a composite element has autowire="true" set, this means that autowiring is enabled for all component references within that composite. In this example, autowiring can be turned off for specific components and specific references through setting autowire="false" on the components and references concerned.
REF ASM60022 \h For each component reference for which autowire is enabled, the the SCA runtime MUST search within the composite for target services which are compatible with the reference. [ASM60022] "Compatible" here means:
REF ASM60023 \h the target service interface MUST be a compatible superset of the reference interface when using autowire to wire a reference (as defined in the section on Wires) [ASM60023]
REF ASM60024 \h the intents, and policies applied to the service MUST be compatible with those on the reference when using autowire to wire a reference so that wiring the reference to the service will not cause an error due to policy mismatch [ASM60024] (see HYPERLINK \l "Ref10" the Policy Framework specification [10] for details)
If the search finds 1 or more valid target service for a particular reference, the action taken depends on the multiplicity of the reference:
REF ASM60025 \h for an autowire reference with multiplicity 0..1 or 1..1, the SCA runtime MUST wire the reference to one of the set of valid target services chosen from the set in a runtime-dependent fashion [ASM60025]
REF ASM60026 \h for an autowire reference with multiplicity 0..n or 1..n, the reference MUST be wired to all of the set of valid target services [ASM60026]
If the search finds no valid target services for a particular reference, the action taken depends on the multiplicy of the reference:
REF ASM60027 \h for an autowire reference with multiplicity 0..1 or 0..n, if the SCA runtime finds no valid target service, there is no problem no services are wired and the SCA runtime MUST NOT raise an error [ASM60027]
REF ASM60028 \h for an autowire reference with multiplicity 1..1 or 1..n, if the SCA runtime finds no valid target services an error MUST be raised by the SCA runtime since the reference is intended to be wired [ASM60028]
Autowire Examples
This example demonstrates two versions of the same composite the first version is done using explicit wires, with no autowiring used, the second version is done using autowire. In both cases the end result is the same the same wires connect the references to the services.
First, here is a diagram for the composite:
Figure SEQ Figure \* ARABIC 12: Example Composite for Autowire
First, the composite using explicit wires:
Secondly, the composite using autowire:
In this second case, autowire is set on for the PaymentsComponent and there are no explicit wires for any of its references the wires are created automatically through autowire.
Note: In the second example, it would be possible to omit all of the service and reference elements from the PaymentsComponent. They are left in for clarity, but if they are omitted, the component service and references still exist, since they are provided by the implementation used by the component.
Using Composites as Component Implementations
Composites may form component implementations in higher-level composites in other words the higher-level composites can have components which are implemented by composites.
When a composite is used as a component implementation, it defines a boundary of visibility. Components within the composite cannot be referenced directly by the using component. The using component can only connect wires to the services and references of the used composite and set values for any properties of the composite. The internal construction of the composite is invisible to the using component.
A composite used as a component implementation needs to also honor a completeness contract. The services, references and properties of the composite form a contract which is relied upon by the using component. The concept of completeness of the composite implies:
the composite must have at least one service or at least one reference.A component with no services and no references is not meaningful in terms of SCA, since it cannot be wired to anything it neither provides nor consumes any services
each service offered by the composite must be wired to a service of a component or to a composite reference. If services are left unwired, the implication is that some exception will occur at runtime if the service is invoked.
The component type of a composite is defined by the set of service elements, reference elements and property elements that are the children of the composite element.
Composites are used as component implementations through the use of the implementation.composite element as a child element of the component. The schema snippet for the implementation.composite element is:
...
*
?
*
?
*
?
+
*
property-value
*
?
*
?
+
...
The implementation.composite element has the following attribute:
name (1..1) the name of the composite used as an implementation. REF ASM60030 \h The @name attribute of an element MUST contain the QName of a composite in the SCA Domain. [ASM60030]
Example of Composite used as a Component Implementation
The following in an example of a composite which contains two components, each of which is implemented by a composite:
EURO
Using Composites through Inclusion
In order to assist team development, composites may be developed in the form of multiple physical artifacts that are merged into a single logical unit.
A composite is defined in an xxx.composite file and the composite may receive additional content through the inclusion of other composite files.
The semantics of included composites are that the content of the included composite is inlined into the using composite xxx.composite file through include elements in the using composite. The effect is one of textual inclusion that is, the text content of the included composite is placed into the using composite in place of the include statement. The included composite element itself is discarded in this process only its contents are included.
The composite file used for inclusion can have any contents, but always contains a single composite element. The composite element can contain any of the elements which are valid as child elements of a composite element, namely components, services, references, wires and includes. There is no need for the content of an included composite to be complete, so that artifacts defined within the using composite or in another associated included composite file may be referenced. For example, it is permissible to have two components in one composite file while a wire specifying one component as the source and the other as the target can be defined in a second included composite file.
REF ASM60031 \h The SCA runtime MUST raise an error if the composite resulting from the inclusion of one composite into another is invalid. [ASM60031] For example, it is an error if there are duplicated elements in the using composite (eg. two services with the same uri contributed by different included composites), or if there are wires with non-existent source or target.
The following snippet shows the partial schema for the include element.
...
*
...
The include element has the following attribute:
name (required) the name of the composite that is included.
Included Composite Examples
The following figure shows the assembly diagram for the MyValueComposite2 containing four included composites. The MyValueServices composite contains the MyValueService service. The MyValueComponents composite contains the MyValueServiceComponent and the StockQuoteMediatorComponent as well as the wire between them. The MyValueReferences composite contains the CustomerService and StockQuoteService references. The MyValueWires composite contains the wires that connect the MyValueService service to the MyValueServiceComponent, that connect the customerService reference of the MyValueServiceComponent to the CustomerService reference, and that connect the stockQuoteService reference of the StockQuoteMediatorComponent to the StockQuoteService reference. Note that this is just one possible way of building the MyValueComposite2 from a set of included composites.
Figure SEQ Figure \* ARABIC 13 MyValueComposite2 built from 4 included composites
The following snippet shows the contents of the MyValueComposite2.composite file for the MyValueComposite2 built using included composites. In this sample it only provides the name of the composite. The composite file itself could be used in a scenario using included composites to define components, services, references and wires.
The following snippet shows the content of the MyValueServices.composite file.
The following snippet shows the content of the MyValueComponents.composite file.
EUROEURO
The following snippet shows the content of the MyValueReferences.composite file.
The following snippet shows the content of the MyValueWires.composite file.
Composites which Include Component Implementations of Multiple Types
A Composite containing multiple components can have multiple component implementation types. For example, a Composite may include one component with a Java POJO as its implementation and another component with a BPEL process as its implementation.
ConstrainingType
SCA allows a component, and its associated implementation, to be constrained by a constrainingType. The constrainingType element provides assistance in developing top-down usecases in SCA, where an architect or assembler can define the structure of a composite, including the required form of component implementations, before any of the implementations are developed.
A constrainingType is expressed as an element which has services, reference and properties as child elements and which can have intents applied to it. The constrainingType is independent of any implementation. Since it is independent of an implementation it cannot contain any implementation-specific configuration information or defaults. Specifically, it cannot contain bindings, policySets, property values or default wiring information. The constrainingType is applied to a component through a constrainingType attribute on the component.
A constrainingType provides the "shape" for a component and its implementation. Any component configuration that points to a constrainingType is constrained by this shape. REF ASM70001 \h The constrainingType specifies the services, references and properties that MUST be implemented by the implementation of the component to which the constrainingType is attached. [ASM70001] This provides the ability for the implementer to program to a specific set of services, references and properties as defined by the constrainingType. Components are therefore configured instances of implementations and are constrained by an associated constrainingType.
REF ASM70002 \h If the configuration of the component or its implementation do not conform to the constrainingType specified on the component element, the SCA runtime MUST raise an error. [ASM70002]
A constrainingType is represented by a constrainingType element. The following snippet shows the pseudo-schema for the composite element.
*
?
*
?
*
default-property-value?
The constrainingType element has the following attributes:
name (1..1) the name of the constrainingType. The form of a constraingType name is an XML QName, in the namespace identified by the targetNamespace attribute. REF ASM70003 \h The name attribute of the constraining type MUST be unique in the SCA domain. [ASM70003]
targetNamespace (0..1) an identifier for a target namespace into which the constrainingType is declared
requires (0..1) a list of policy intents. See HYPERLINK \l "Ref10" the Policy Framework specification [10] for a description of this attribute.
ConstrainingType contains zero or more properties, services, references.
REF ASM70004 \h When an implementation is constrained by a constrainingType its component type MUST contain all the services, references and properties specified in the constrainingType. [ASM70004] The constraining types references and services will have interfaces specified and can have intents specified. REF ASM70005 \h An implementation MAY contain additional services, additional optional references (multiplicity 0..1 or 0..n) and additional optional properties beyond those declared in the constraining type, but MUST NOT contain additional non-optional references (multiplicity 1..1 or 1..n) or additional non-optional properties (a property with mustSupply=true). [ASM70005]
When a component is constrained by a constrainingType via the "constrainingType" attribute, the entire componentType associated with the component and its implementation is not visible to the containing composite. The containing composite can only see a projection of the componentType associated with the component and implementation as scoped by the constrainingType of the component. REF ASM70006 \h Additional services, references and properties provided by the implementation which are not declared in the constrainingType associated with a component MUST NOT be configured in any way by the containing composite. [ASM70006] This requirement ensures that the constrainingType contract cannot be violated by the composite.
The constrainingType can include required intents on any element. Those intents are applied to any component that uses that constrainingType. In other words, if requires=reliability exists on a constrainingType, or its child service or reference elements, then a constrained component or its implementation must include requires=reliability on the component or implementation or on its corresponding service or reference. REF ASM70007 \h A component or implementation can use a qualified form of an intent specified in unqualified form in the constrainingType, but if the constrainingType uses the qualified form of an intent, then the component or implementation MUST also use the qualified form, otherwise there is an error. [ASM70007]
A constrainingType can be applied to an implementation. In this case, the implementation's componentType has a constrainingType attribute set to the QName of the constrainingType.
Example constrainingType
The following snippet shows the contents of the component called "MyValueServiceComponent" which is constrained by the constrainingType myns:CT. The componentType associated with the implementation is also shown.
EURO
The component MyValueServiceComponent is constrained by the constrainingType CT which means that it must provide:
service MyValueService with the interface services.myvalue.MyValueService
reference customerService with the interface services.stockquote.StockQuoteService
reference stockQuoteService with the interface services.stockquote.StockQuoteService
property currency of type xsd:string.
Interface
Interfaces define one or more business functions. These business functions are provided by Services and are used by References. A Service offers the business functionality of exactly one interface for use by other components. Each interface defines one or more service operations and each operation has zero or one request (input) message and zero or one response (output) message. The request and response messages can be simple types such as a string value or they can be complex types.
SCA currently supports the following interface type systems:
Java interfaces
WSDL 1.1 portTypes ( HYPERLINK \l "Ref8" Web Services Definition Language [8])
WSDL 2.0 interfaces ( HYPERLINK \l "Ref8" Web Services Definition Language [8])
C++ classes
SCA is also extensible in terms of interface types. Support for other interface type systems can be added through the extensibility mechanisms of SCA, as described in HYPERLINK \l "_Extension_Model" the Extension Model section.
The following snippet shows the definition for the interface base element.
The interface base element has the following attributes:
requires : QName (0..n) a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute
policySets : QName (0..n) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
The following snippet shows a sample for the WSDL portType (WSDL 1.1) or WSDL interface (WSDL 2.0) element.
The interface.wsdl element has the following attributes:
interface URI of the portType/interface with the following format.
#wsdl.interface()
REF ASM80001 \h The interface.wsdl @interface attribute MUST reference a portType of a WSDL 1.0 document OR an interface element of a WSDL 2.0 document. [ASM80001]
The following snippet shows a sample for the WSDL portType/interface element.
For WSDL 1.1, the interface attribute points to a portType in the WSDL. For WSDL 2.0, the interface attribute points to an interface in the WSDL. For the WSDL 1.1 portType and WSDL 2.0 interface type systems, arguments and return of the service operations are described using XML schema.
For information about Java interfaces, including details of SCA-specific annotations, see the SCA Java Common Annotations and APIs specification [1].
Local and Remotable Interfaces
A remotable service is one which may be called by a client which is running in an operating system process different from that of the service itself (this also applies to clients running on different machines from the service). Whether a service of a component implementation is remotable is defined by the interface of the service. In the case of Java this is defined by adding the @Remotable annotation to the Java interface (see HYPERLINK \l "Ref1" Client and Implementation Model Specification for Java). WSDL defined interfaces are always remotable.
The style of remotable interfaces is typically coarse grained and intended for loosely coupled interactions. REF ASM80002 \h Remotable service Interfaces MUST NOT make use of method or operation overloading. [ASM80002]Independent of whether the remotable service is called remotely from outside the process where the service runs or from another component running in the same process, the data exchange semantics are by-value.
Implementations of remotable services can modify input messages (parameters) during or after an invocation and can modify return messages (results) after the invocation. REF ASM80003 \h If a remotable service is called locally or remotely, the SCA container MUST ensure sure that no modification of input messages by the service or post-invocation modifications to return messages are seen by the caller. [ASM80003]
Here is a snippet which shows an example of a remotable java interface:
package services.hello;
@Remotable
public interface HelloService {
String hello(String message);
}
It is possible for the implementation of a remotable service to indicate that it can be called using by-reference data exchange semantics when it is called from a component in the same process. This can be used to improve performance for service invocations between components that run in the same process. This can be done using the @AllowsPassByReference annotation (see the HYPERLINK \l "Ref1" Java Client and Implementation Specification).
A service typed by a local interface can only be called by clients that are running in the same process as the component that implements the local service. Local services cannot be published via remotable services of a containing composite. In the case of Java a local service is defined by a Java interface definition without a @Remotable annotation.
The style of local interfaces is typically fine grained and intended for tightly coupled interactions. Local service interfaces can make use of method or operation overloading.
The data exchange semantic for calls to services typed by local interfaces is by-reference.
Bidirectional Interfaces
The relationship of a business service to another business service is often peer-to-peer, requiring a two-way dependency at the service level. In other words, a business service represents both a consumer of a service provided by a partner business service and a provider of a service to the partner business service. This is especially the case when the interactions are based on asynchronous messaging rather than on remote procedure calls. The notion of bidirectional interfaces is used in SCA to directly model peer-to-peer bidirectional business service relationships.
An interface element for a particular interface type system needs to allow the specification of an optional callback interface. If a callback interface is specified, SCA refers to the interface as a whole as a bidirectional interface.
The following snippet shows the interface element defined using Java interfaces with an optional callbackInterface attribute.
If a service is defined using a bidirectional interface element then its implementation implements the interface, and its implementation uses the callback interface to converse with the client that called the service interface.
REF ASM80004 \h If a reference is defined using a bidirectional interface element, the client component implementation using the reference calls the referenced service using the interface. The client MUST provide an implementation of the callback interface. [ASM80004]
Callbacks can be used for both remotable and local services. REF ASM80005 \h Either both interfaces of a bidirectional service MUST be remotable, or both MUST be local. A bidirectional service MUST NOT mix local and remote services. [ASM80005]
Conversational Interfaces
Services sometimes cannot easily be defined so that each operation stands alone and is completely independent of the other operations of the same service. Instead, there is a sequence of operations that must be called in order to achieve some higher level goal. SCA calls this sequence of operations a conversation. If the service uses a bidirectional interface, the conversation may include both operations and callbacks.
Such conversational services are typically managed by using conversation identifiers that are either (1) part of the application data (message parts or operation parameters) or 2) communicated separately from application data (possibly in headers). SCA introduces the concept of conversational interfaces for describing the interface contract for conversational services of the second form above. With this form, it is possible for the runtime to automatically manage the conversation, with the help of an appropriate binding specified at deployment. SCA does not standardize any aspect of conversational services that are maintained using application data. Such services are neither helped nor hindered by SCAs conversational service support.
Conversational services typically involve state data that relates to the conversation that is taking place. The creation and management of the state data for a conversation has a significant impact on the development of both clients and implementations of conversational services.
Traditionally, application developers who have needed to write conversational services have been required to write a lot of plumbing code. They need to:
choose or define a protocol to communicate conversational (correlation) information between the client & provider
route conversational messages in the provider to a machine that can handle that conversation, while handling concurrent data access issues
write code in the client to use/encode the conversational information
maintain state that is specific to the conversation, sometimes persistently and transactionally, both in the implementation and the client.
SCA makes it possible to divide the effort associated with conversational services between a number of roles:
Application Developer: Declares that a service interface is conversational (leaving the details of the protocol up to the binding). Uses lifecycle semantics, APIs or other programmatic mechanisms (as defined by the implementation-type being used) to manage conversational state.
Application Assembler: chooses a binding that can support conversations
Binding Provider: implements a protocol that can pass conversational information with each operation request/response.
Implementation-Type Provider: defines APIs and/or other programmatic mechanisms for application developers to access conversational information. Optionally implements instance lifecycle semantics that automatically manage implementation state based on the binding's conversational information.
There is a policy intent with the name conversational which is used to mark an interface as being conversational in nature. REF ASM80006 \h Where a service or a reference has a conversational interface, the conversational intent MUST be attached either to the interface itself, or to the service or reference using the interface. [ASM80006] How to attach the conversational intent to an interface depends on the type of the interface. For a WSDL interface, this is described in section HYPERLINK \l "_SCA-Specific_Aspects_for" 8.4 "SCA-Specific Aspects for WSDL Interfaces". For a Java interface, it is described in the Java Common Annotations and APIs specification. Note that setting the conversational intent on the service or reference element is useful when reusing an existing interface definition that contains no SCA information, since it requires no modification of the interface artifact.
The meaning of the conversational intent is that both the client and the provider of the interface can assume that messages (in either direction) will be handled as part of an ongoing conversation without depending on identifying information in the body of the message (i.e. in parameters of the operations). In effect, the conversation interface specifies a high-level abstract protocol that must be satisfied by any actual binding/policy combination used by the service.
Examples of binding/policy combinations that support conversational interfaces are:
Web service binding with a WS-RM policy
Web service binding with a WS-Addressing policy
Web service binding with a WS-Context policy
JMS binding with a conversation policy that uses the JMS correlationID header
Conversations occur between one client and one target service. Consequently, requests originating from one client to multiple target conversational services will result in multiple conversations. For example, if a client A calls services B and C, both of which implement conversational interfaces, two conversations result, one between A and B and another between A and C. Likewise, requests flowing through multiple implementation instances will result in multiple conversations. For example, a request flowing from A to B and then from B to C will involve two conversations (A and B, B and C). In the previous example, if a request was then made from C to A, a third conversation would result (and the implementation instance for A would be different from the one making the original request).
Invocation of any operation of a conversational interface can start a conversation. The decision on whether an operation starts a conversation depends on the components implementation and its implementation type. Implementation types can support components which provide conversational services. If an implementation type does provide this support, the specification for that implementation type defines a mechanism for determining when a new conversation should be used for an operation (for example, in Java, the conversation is new on the first use of an injected reference; in BPEL, the conversation is new when the clients partnerLink comes into scope).
One or more operations in a conversational interface can be annotated with an endsConversation annotation (the mechanism for annotating the interface depends on the interface type) which indicates that when the operation is invoked, the conversation is at an end. Where an interface is bidirectional, operations may also be annotated in this way on operations of the callback interface. When a conversation ending operation is called, it indicates to both the client and the service provider that the conversation is complete. REF ASM80007 \h Once an operation marked with endsConversation has been invoked, any subsequent attempts to call an operation or a callback operation associated with the same conversation MUST generate a sca:ConversationViolation fault. [ASM80007]
A sca:ConversationViolation fault is thrown when one of the following errors occurr:
A message is received for a particular conversation, after the conversation has ended
The conversation identification is invalid (not unique, out of range, etc.)
The conversation identification is not present in the input message of the operation that ends the conversation
The client or the service attempts to send a message in a conversation, after the conversation has ended
This fault is named within the SCA namespace standard prefix sca, which corresponds to URI HYPERLINK "http://www.osoa.org/xmlns/sca/1.0" http://docs.oasis-open.org/ns/opencsa/sca/200712.
The lifecycle of resources and the association between unique identifiers and conversations are determined by the services implementation type and may not be directly affected by the endConversation annotation. For example, a WS-BPEL process can outlive most of the conversations that it is involved in.
Although conversational interfaces do not require that any identifying information be passed as part of the body of messages, there is conceptually an identity associated with the conversation. Individual implementations types can have an API to access the ID associated with the conversation, although no assumptions can be made about the structure of that identifier. Implementation types can also have a means to set the conversation ID by either the client or the service provider, although the operation may only be supported by some binding/policy combinations.
Implementation-type specifications are encouraged to define and provide conversational instance lifecycle management for components that implement conversational interfaces. However, implementations could also manage the conversational state manually.
SCA-Specific Aspects for WSDL Interfaces
There are a number of aspects that SCA applies to interfaces in general, such as marking them conversational. These aspects apply to the interfaces themselves, rather than their use in a specific place within SCA. There is thus a need to provide appropriate ways of marking the interface definitions themselves, which go beyond the basic facilities provided by the interface definition language.
For WSDL interfaces, there is an extension mechanism that permits additional information to be included within the WSDL document. SCA takes advantage of this extension mechanism. In order to use the SCA extension mechanism, the SCA namespace ( HYPERLINK "http://www.osoa.org/xmlns/sca/1.0" http://docs.oasis-open.org/ns/opencsa/sca/200712) needs to be declared within the WSDL document.
First, SCA defines a global attribute in the SCA namespace which provides a mechanism to attach policy intents - @requires. The definition of this attribute is as follows:
The @requires attribute can be applied to WSDL Port Type elements (WSDL 1.1) and to WSDL Interface elements (WSDL 2.0). The attribute contains one or more intent names, as defined by HYPERLINK \l "Ref10" the Policy Framework specification [10]. REF ASM80008 \h Any service or reference that uses an interface marked with required intents MUST implicitly add those intents to its own @requires list. [ASM80008]
To specify that a WSDL interface is conversational, the following attribute setting is used on either the WSDL Port Type or WSDL Interface:
requires="conversational"
SCA defines an endsConversation attribute that is used to mark specific operations within a WSDL interface declaration as ending a conversation. This only has meaning for WSDL interfaces which are also marked conversational. The endsConversation attribute is a global attribute in the SCA namespace, with the following definition:
The following snippet is an example of a WSDL Port Type annotated with the requires attribute on the portType and the endsConversation attribute on one of the operations:
...
...
...
Binding
Bindings are used by services and references. References use bindings to describe the access mechanism used to call a service (which can be a service provided by another SCA composite). Services use bindings to describe the access mechanism that clients (which can be a client from another SCA composite) have to use to call the service.
SCA supports the use of multiple different types of bindings. Examples include SCA service, Web service, stateless session EJB, data base stored procedure, EIS service. An SCA runtime MUST provide support for SCA service and Web service binding types. SCA provides an extensibility mechanism by which an SCA runtime can add support for additional binding types. For details on how additional binding types are defined, see the section on the Extension Model.
A binding is defined by a binding element which is a child element of a service or of a reference element in a composite. The following snippet shows the composite schema with the schema for the binding element.
...
*
?
*
?
+
...
*
?
*
?
+
...
The element name of the binding element is architected; it is in itself a qualified name. The first qualifier is always named binding, and the second qualifier names the respective binding-type (e.g. binding.composite, binding.ws, binding.ejb, binding.eis).
A binding element has the following attributes:
uri (0..1) - has the following semantic.
The uri attribute can be omitted.
REF ASM90001 \h For a binding of a reference the URI attribute defines the target URI of the reference. This MUST be either the componentName/serviceName for a wire to an endpoint within the SCA domain, or the accessible address of some service endpoint either inside or outside the SCA domain (where the addressing scheme is defined by the type of the binding). [ASM90001]
The circumstances under which the uri attribute can be used are defined in section HYPERLINK \l "_Specifying_the_Target" "5.3.1 Specifying the Target Service(s) for a Reference."
For a binding of a service the URI attribute defines the URI relative to the component, which contributes the service to the SCA domain. The default value for the URI is the value of the name attribute of the binding.
name (0..1) a name for the binding instance (an NCName). The name attribute allows distinction between multiple binding elements on a single service or reference. The default value of the name attribute is the service or reference name. REF ASM90002 \h When a service or reference has multiple bindings, only one binding can have the default name value; all others must have a name value specified that is unique within the service or reference. [ASM90002] The name also permits the binding instance to be referenced from elsewhere particularly useful for some types of binding, which can be declared in a definitions document as a template and referenced from other binding instances, simplifying the definition of more complex binding instances (see HYPERLINK \l "Ref11" the JMS Binding specification [11] for examples of this referencing).
requires (optional) - a list of policy intents. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
policySets (optional) a list of policy sets. See the HYPERLINK \l "Ref10" Policy Framework specification [10] for a description of this attribute.
When multiple bindings exist for an service, it means that the service is available by any of the specified bindings. The technique that the SCA runtime uses to choose among available bindings is left to the implementation and it may include additional (nonstandard) configuration. Whatever technique is used needs to be documented by the runtime.
Services and References can always have their bindings overridden at the SCA domain level, unless restricted by Intents applied to them.
REF ASM90003 \h If a reference has any bindings they MUST be resolved which means that each binding MUST include a value for the @URI attribute or MUST otherwise specify an endpoint. The reference MUST NOT be wired using other SCA mechanisms. [ASM90003] To specify constraints on the kinds of bindings that are acceptable for use with a reference, the user specifies either policy intents or policy sets. Users can also specifically wire, not just to a component service, but to a specific binding offered by that target service. To do so, REF ASM90004 \h a wire target MAY be specified with a syntax of "componentName/serviceName/bindingName". [ASM90004]
The following sections describe the SCA and Web service binding type in detail.
Messages containing Data not defined in the Service Interface
It is possible for a message to include information that is not defined in the interface used to define the service, for instance information may be contained in SOAP headers or as MIME attachments.
Implementation types can make this information available to component implementations in their execution context. The specifications for these implementation types describe how this information is accessed and in what form it is presented.
Form of the URI of a Deployed Binding
Constructing Hierarchical URIs
Bindings that use hierarchical URI schemes construct the effective URI with a combination of the following pieces:
Base System URI for a scheme / Component URI / Service Binding URI
Each of these components deserves addition definition:
Base Domain URI for a scheme. An SCA domain should define a base URI for each hierarchical URI scheme on which it intends to provide services.
For example: the HTTP and HTTPS schemes would each have their own base URI defined for the domain. An example of a scheme that is not hierarchical, and therefore will have no base URI is the jms: scheme.
Component URI. The component URI above is for a component that is deployed in the SCA Domain. The URI of a component defaults to the name of the component, which is used as a relative URI. The component may have a specified URI value. The specified URI value may be an absolute URI in which case it becomes the Base URI for all the services belonging to the component. If the specified URI value is a relative URI, it is used as the Component URI value above.
Service Binding URI. The Service Binding URI is the relative URI specified in the uri attribute of a binding element of the service. The default value of the attribute is value of the bindings name attribute treated as a relative URI. If multiple bindings for a single service use the same scheme (e.g. HTTP), then only one of the bindings may depend on the default value for the uri attribute, i.e. only one may use the default binding name. The service binding URI may also be absolute, in which case the absolute URI fully specifies the full URI of the service. Some deployment environments may not support the use of absolute URIs in service bindings.
Services deployed into the Domain (as opposed to services of components) have a URI that does not include a component name, i.e.:
Base Domain URI for a scheme / Service Binding URI
The name of the containing composite does not contribute to the URI of any service.
For example, a service where the Base URI is "http://acme.com", the component is named "stocksComponent" and the service binding name is "getQuote", the URI would look like this:
http://acme.com/stocksComponent/getQuote
Allowing a bindings relative URI to be specified that differs from the name of the service allows the URI hierarchy of services to be designed independently of the organization of the domain.
It is good practice to design the URI hierarchy to be independent of the domain organization, but there may be times when domains are initially created using the default URI hierarchy. When this is the case, the organization of the domain can be changed, while maintaining the form of the URI hierarchy, by giving appropriate values to the uri attribute of select elements. Here is an example of a change that can be made to the organization while maintaining the existing URIs:
To move a subset of the services out of one component (say "foo") to a new component (say bar), the new component should have bindings for the moved services specify a URI ../foo/MovedService..
The URI attribute may also be used in order to create shorter URIs for some endpoints, where the component name may not be present in the URI at all. For example, if a binding has a uri attribute of "../myService" the component name will not be present in the URI.
Non-hierarchical URIs
Bindings that use non-hierarchical URI schemes (such as jms: or mailto:) may optionally make use of the uri attritibute, which is the complete representation of the URI for that service binding. Where the binding does not use the "uri" attribute, the binding must offer a different mechanism for specifying the service address.
Determining the URI scheme of a deployed binding
One of the things that needs to be determined when building the effective URI of a deployed binding (i.e. endpoint) is the URI scheme. The process of determining the endpoint URI scheme is binding type specific.
If the binding type supports a single protocol then there is only one URI scheme associated with it. In this case, that URI scheme is used.
If the binding type supports multiple protocols, the binding type implementation determines the URI scheme by introspecting the binding configuration, which may include the policy sets associated with the binding.
A good example of a binding type that supports multiple protocols is binding.ws, which can be configured by referencing either an abstract WSDL element (i.e. portType or interface) or a concrete WSDL element (i.e. binding, port or endpoint). When the binding references a PortType or Interface, the protocol and therefore the URI scheme is derived from the intents/policy sets attached to the binding. When the binding references a concrete WSDL element, there are two cases:
The referenced WSDL binding element uniquely identifies a URI scheme. This is the most common case. In this case, the URI scheme is given by the protocol/transport specified in the WSDL binding element.
The referenced WSDL binding element doesnt uniquely identify a URI scheme. For example, when HTTP is specified in the @transport attribute of the SOAP binding element, both http and https could be used as valid URI schemes. In this case, the URI scheme is determined by looking at the policy sets attached to the binding.
Its worth noting that an intent supported by a binding type may completely change the behavior of the binding. For example, when the intent "confidentiality/transport is required by an HTTP binding, SSL is turned on. This basically changes the URI scheme of the binding from http to https.
SCA Binding
The SCA binding element is defined by the following schema.
The SCA binding can be used for service interactions between references and services contained within the SCA domain. The way in which this binding type is implemented is not defined by the SCA specification and it can be implemented in different ways by different SCA runtimes. The only requirement is that the required qualities of service must be implemented for the SCA binding type. The SCA binding type is not intended to be an interoperable binding type. For interoperability, an interoperable binding type such as the Web service binding should be used.
A service definition with no binding element specified uses the SCA binding. would only have to be specified in override cases, or when you specify a set of bindings on a service definition and the SCA binding should be one of them.
If a reference does not have a binding, then the binding used can be any of the bindings specified by the service provider, as long as the intents required by the reference and the service are all respected.
If the interface of the service or reference is local, then the local variant of the SCA binding will be used. If the interface of the service or reference is remotable, then either the local or remote variant of the SCA binding will be used depending on whether source and target are co-located or not.
If a reference specifies an URI via its uri attribute, then this provides the default wire to a service provided by another domain level component. The value of the URI has to be as follows:
/
Example SCA Binding
The following snippet shows the MyValueComposite.composite file for the MyValueComposite containing the service element for the MyValueService and a reference element for the StockQuoteService. Both the service and the reference use an SCA binding. The target for the reference is left undefined in this binding and would have to be supplied by the composite in which this composite is used.
Web Service Binding
SCA defines a Web services binding. This is described in HYPERLINK \l "Ref9" a separate specification document [9].
JMS Binding
SCA defines a JMS binding. This is described in HYPERLINK \l "Ref11" a separate specification document [11].
SCA Definitions
There are a variety of SCA artifacts which are generally useful and which are not specific to a particular composite or a particular component. These shared artifacts include intents, policy sets, bindings, binding type definitions and implementation type definitions.
All of these artifacts within an SCA Domain are defined in a global, SCA Domain-wide file named definitions.xml. The definitions.xml file contains a definitions element that conforms to the following pseudo-schema snippet:
*
*
*
*
*
The definitions element has the following attribute:
targetNamespace (required) the namespace into which the child elements of this definitions element are placed (used for artifact resolution)
The definitions element contains optional child elements intent, policySet, binding, bindingtype and implementationType. These elements are described elsewhere in this specification or in HYPERLINK \l "Ref10" the SCA Policy Framework specification [10]. The use of the elements declared within a definitions element is described in the HYPERLINK \l "Ref10" SCA Policy Framework specification [10] and in HYPERLINK \l "Ref11" the JMS Binding specification [11].
Extension Model
The assembly model can be extended with support for new interface types, implementation types and binding types. The extension model is based on XML schema substitution groups. There are three XML Schema substitution group heads defined in the SCA namespace: interface, implementation and binding, for interface types, implementation types and binding types, respectively.
The SCA Client and Implementation specifications and the SCA Bindings specifications ( HYPERLINK \l "Ref1" see [1], HYPERLINK \l "Ref9" [9], HYPERLINK \l "Ref11" [11]) use these XML Schema substitution groups to define some basic types of interfaces, implementations and bindings, but other types can be defined as required, where support for these extra ones is available from the runtime. The inteface type elements, implementation type elements, and binding type elements defined by the SCA specifications are all part of the SCA namespace ("http://docs.oasis-open.org/ns/opencsa/sca/200712"), as indicated in their respective schemas. New interface types, implementation types and binding types that are defined using this extensibility model, which are not part of these SCA specifications are defined in namespaces other than the SCA namespace.
The "." notation is used in naming elements defined by the SCA specifications ( e.g. , , ), not as a parallel extensibility approach but as a naming convention that improves usability of the SCA assembly language.
Note: How to contribute SCA model extensions and their runtime function to an SCA runtime will be defined by a future version of the specification.
Defining an Interface Type
The following snippet shows the base definition for the interface element and Interface type contained in sca-core.xsd; see appendix for complete schema.
...
...
In the following snippet is an example of how the base definition is extended to support Java interfaces. The snippet shows the definition of the interface.java element and the JavaInterface type contained in sca-interface-java.xsd.
In the following snippet is an example of how the base definition can be extended by other specifications to support a new interface not defined in the SCA specifications. The snippet shows the definition of the my-interface-extension element and the my-interface-extension-type type.
...
Defining an Implementation Type
The following snippet shows the base definition for the implementation element and Implementation type contained in sca-core.xsd; see appendix for complete schema.
...
...
In the following snippet we show how the base definition is extended to support Java implementation. The snippet shows the definition of the implementation.java element and the JavaImplementation type contained in sca-implementation-java.xsd.
In the following snippet is an example of how the base definition can be extended by other specifications to support a new implementation type not defined in the SCA specifications. The snippet shows the definition of the my-impl-extension element and the my-impl-extension-type type.
...
In addition to the definition for the new implementation instance element, there needs to be an associated implementationType element which provides metadata about the new implementation type. The pseudo schema for the implementationType element is shown in the following snippet:
The implementation type has the following attributes:
type (1..1) the type of the implementation to which this implementationType element applies. This is intended to be the QName of the implementation element for the implementation type, such as "sca:implementation.java"
alwaysProvides (0..1) a set of intents which the implementation type always provides. See HYPERLINK \l "Ref10" the Policy Framework specification [10] for details.
mayProvide (0..1) a set of intents which the implementation type may provide. See HYPERLINK \l "Ref10" the Policy Framework specification [10] for details.
Defining a Binding Type
The following snippet shows the base definition for the binding element and Binding type contained in sca-core.xsd; see appendix for complete schema.
...
...
In the following snippet is an example of how the base definition is extended to support Web service binding. The snippet shows the definition of the binding.ws element and the WebServiceBinding type contained in sca-binding-webservice.xsd.
In the following snippet is an example of how the base definition can be extended by other specifications to support a new binding not defined in the SCA specifications. The snippet shows the definition of the my-binding-extension element and the my-binding-extension-type type.
...
In addition to the definition for the new binding instance element, there needs to be an associated bindingType element which provides metadata about the new binding type. The pseudo schema for the bindingType element is shown in the following snippet:
The binding type has the following attributes:
type (1..1) the type of the binding to which this bindingType element applies. This is intended to be the QName of the binding element for the binding type, such as "sca:binding.ws"
alwaysProvides (0..1) a set of intents which the binding type always provides. See HYPERLINK \l "Ref10" the Policy Framework specification [10] for details.
mayProvide (0..1) a set of intents which the binding type may provide. See HYPERLINK \l "Ref10" the Policy Framework specification [10] for details.
Packaging and Deployment
Domains
An SCA Domain represents a complete runtime configuration, potentially distributed over a series of interconnected runtime nodes.
A single SCA domain defines the boundary of visibility for all SCA mechanisms. For example, SCA wires can only be used to connect components within a single SCA domain. Connections to services outside the domain must use binding specific mechanisms for addressing services (such as WSDL endpoint URIs). Also, SCA mechanisms such as intents and policySets can only be used in the context of a single domain. In general, external clients of a service that is developed and deployed using SCA should not be able to tell that SCA was used to implement the service it is an implementation detail.
The size and configuration of an SCA Domain is not constrained by the SCA Assembly specification and is expected to be highly variable. An SCA Domain typically represents an area of business functionality controlled by a single organization. For example, an SCA Domain may be the whole of a business, or it may be a department within a business.
As an example, for the accounts department in a business, the SCA Domain might cover all finance-related functions, and it might contain a series of composites dealing with specific areas of accounting, with one for Customer accounts and another dealing with Accounts Payable.
An SCA domain has the following:
A virtual domain-level composite whose components are deployed and running
A set of installed contributions that contain implementations, interfaces and other artifacts necessary to execute components
A set of logical services for manipulating the set of contributions and the virtual domain-level composite.
The information associated with an SCA domain can be stored in many ways, including but not limited to a specific filesystem structure or a repository.
Contributions
An SCA domain might require a large number of different artifacts in order to work. These artifacts include artifacts defined by SCA and other artifacts such as object code files and interface definition files. The SCA-defined artifact types are all XML documents. The root elements of the different SCA definition documents are: composite, componentType, constrainingType and definitions. XML artifacts that are not defined by SCA but which may be needed by an SCA domain include XML Schema documents, WSDL documents, and BPEL documents. SCA constructs, like other XML-defined constructs, use XML qualified names for their identity (i.e. namespace + local name).
Non-XML artifacts are also required within an SCA domain. The most obvious examples of such non-XML artifacts are Java, C++ and other programming language files necessary for component implementations. Since SCA is extensible, other XML and non-XML artifacts may also be required.
SCA defines an interoperable packaging format for contributions (ZIP), as specified below. This format is not the only packaging format that an SCA runtime can use. SCA allows many different packaging formats, but requires that the ZIP format be supported. When using the ZIP format for deploying a contribution, this specification does not specify whether that format is retained after deployment. For example, a Java EE based SCA runtime may convert the ZIP package to an EAR package. SCA expects certain characteristics of any packaging:
REF ASM12001 \h For any contribution packaging it MUST be possible to present the artifacts of the packaging to SCA as a hierarchy of resources based off of a single root [ASM12001]
REF ASM12002 \h Within any contribution packaging A directory resource SHOULD exist at the root of the hierarchy named META-INF [ASM12002]
REF ASM12003 \h Within any contribution packaging a document SHOULD exist directly under the META-INF directory named sca-contribution.xml which lists the SCA Composites within the contribution that are runnable. [ASM12003] The same document also optionally lists namespaces of constructs that are defined within the contribution and which may be used by other contributions REF ASM12004 \h Optionally, in the sca-contribution.xml file, additional elements MAY exist that list the namespaces of constructs that are needed by the contribution and which are be found elsewhere, for example in other contributions. [ASM12004] These optional elements may not be physically present in the packaging, but may be generated based on the definitions and references that are present, or they may not exist at all if there are no unresolved references.See the section "SCA Contribution Metadata Document" for details of the format of this file.
To illustrate that a variety of packaging formats can be used with SCA, the following are examples of formats that might be used to package SCA artifacts and metadata (as well as other artifacts) as a contribution:
A filesystem directory
An OSGi bundle
A compressed directory (zip, gzip, etc)
A JAR file (or its variants WAR, EAR, etc)
Contributions do not contain other contributions. If the packaging format is a JAR file that contains other JAR files (or any similar nesting of other technologies), the internal files are not treated as separate SCA contributions. It is up to the implementation to determine whether the internal JAR file should be represented as a single artifact in the contribution hierarchy or whether all of the contents should be represented as separate artifacts.
A goal of SCAs approach to deployment is that the contents of a contribution should not need to be modified in order to install and use the contents of the contribution in a domain.
SCA Artifact Resolution
Contributions may be self-contained, in that all of the artifacts necessary to run the contents of the contribution are found within the contribution itself. However, it can also be the case that the contents of the contribution make one or many references to artifacts that are not contained within the contribution. These references can be to SCA artifacts or they can be to other artifacts such as WSDL files, XSD files or to code artifacts such as Java class files and BPEL scripts.
A contribution can use some artifact-related or packaging-related means to resolve artifact references. Examples of such mechanisms include:
wsdlLocation and schemaLocation attributes in references to WSDL and XSD schema artifacts respectively
OSGi bundle mechanisms for resolving Java class and related resource dependencies
REF ASM12005 \h Where present, artifact-related or packaging-related mechanisms MUST be used to resolve artifact dependencies. [ASM12005]
SCA also provides an artifact resolution mechanism. The SCA artifact resolution mechanisms are used either where no other mechanisms are available, or in cases where the mechanisms used by the various contributions in the same SCA Domain are different. An example of the latter case is where an OSGi Bundle is used for one contribution but where a second contribution used by the first one is not implemented using OSGi - eg the second contribution is a mainframe COBOL service whose interfaces are declared using WSDL which must be accessed by the first contribution.
The SCA artifact resolution is likely to be most useful for SCA domains containing heterogeneous mixtures of contribution, where artifact-related or packaging-related mechanisms are unlikely to work across different kinds of contribution.
SCA artifact resolution works on the principle that a contribution which needs to use artifacts defined elsewhere expresses these dependencies using import statements in metadata belonging to the contribution. A contribution controls which artifacts it makes available to other contributions through export statements in metadata attached to the contribution.
SCA Contribution Metadata Document
The contribution optionally contains a document that declares runnable composites, exported definitions and imported definitions. The document is found at the path of META-INF/sca-contribution.xml relative to the root of the contribution. Frequently some SCA metadata needs to be specified by hand while other metadata is generated by tools (such as the elements described below). To accommodate this, it is also possible to have an identically structured document at META-INF/sca-contribution-generated.xml. If this document exists (or is generated on an as-needed basis), it will be merged into the contents of sca-contribution.xml, with the entries in sca-contribution.xml taking priority if there are any conflicting declarations.The format of the document is:
*
*
*
deployable element: Identifies a composite which is a composite within the contribution that is a composite intended for potential inclusion into the virtual domain-level composite. Other composites in the contribution are not intended for inclusion but only for use by other composites. New composites can be created for a contribution after it is installed, by using the HYPERLINK \l "_add_Deployment_Composite" add Deployment Composite capability and the add To Domain Level Composite capability.
Attributes of the deployable element:
composite (1..1) The QName of a composite within the contribution.
Export element: A declaration that artifacts belonging to a particular namespace are exported and are available for use within other contributions. An export declaration in a contribution specifies a namespace, all of whose definitions are considered to be exported. By default, definitions are not exported.
The SCA artifact export is useful for SCA domains containing heterogeneous mixtures of contribution packagings and technologies, where artifact-related or packaging-related mechanisms are unlikely to work across different kinds of contribution.
Attributes of theexport element:
namespace (1..1) For XML definitions, which are identified by QNames, the namespace should be the namespace URI for the exported definitions. For XML technologies that define multiple symbol spaces that can be used within one namespace (e.g. WSDL port types are a different symbol space from WSDL bindings), all definitions from all symbol spaces are exported. Technologies that use naming schemes other than QNames must use a different export element from the same substitution group as the the SCA element. The element used identifies the technology, and can use any value for the namespace that is appropriate for that technology. For example, can be used can be used to export java definitions, in which case the namespace is a fully qualified package name.
Import element: Import declarations specify namespaces of definitions that are needed by the definitions and implementations within the contribution, but which are not present in the contribution. It is expected that in most cases import declarations will be generated based on introspection of the contents of the contribution. In this case, the import declarations would be found in the META-INF/ sca-contribution-generated.xml document.
Attributes of the import element:
namespace (1..1) For XML definitions, which are identified by QNames, the namespace is the namespace URI for the imported definitions. For XML technologies that define multiple symbol spaces that can be used within one namespace (e.g. WSDL port types are a different symbol space from WSDL bindings), all definitions from all symbol spaces are imported. Technologies that use naming schemes other than QNames must use a different import element from the same substitution group as the the SCA element. The element used identifies the technology, and can use any value for the namespace that is appropriate for that technology. For example, can be used can be used to import java definitions, in which case the namespace is a fully qualified package name.
location (0..1) a URI to resolve the definitions for this import. SCA makes no specific requirements for the form of this URI, nor the means by which it is resolved. It can point to another contribution (through its URI) or it can point to some location entirely outside the SCA Domain.
It is expected that SCA runtimes can define implementation specific ways of resolving location information for artifact resolution between contributions. These mechanisms will however usually be limited to sets of contributions of one runtime technology and one hosting environment.
In order to accommodate imports of artifacts between contributions of disparate runtime technologies, it is strongly suggested that SCA runtimes honor SCA contribution URIs as location specification.
SCA runtimes that support contribution URIs for cross-contribution resolution of SCA artifacts are expected to do so similarly when used as @schemaLocation and @wsdlLocation and other artifact location specifications.
The order in which the import statements are specified can play a role in this mechanism. Since definitions of one namespace can be distributed across several artifacts, multiple import declarations can be made for one namespace.
The location value is only a default, and dependent contributions listed in the call to installContribution can override the value if there is a conflict. However, the specific mechanism for resolving conflicts between contributions that define conflicting definitions is implementation specific.
If the value of the location attribute is an SCA contribution URI, then the contribution packaging can become dependent on the deployment environment. In order to avoid such a dependency, dependent contributions should be specified only when deploying or updating contributions as specified in the section 'Operations for Contributions' below.
Contribution Packaging using ZIP
SCA allows many different packaging formats that SCA runtimes can support, but REF ASM12006 \h SCA requires that all runtimes MUST support the ZIP packaging format for contributions. [ASM12006] This format allows that metadata specified by the section 'SCA Contribution Metadata Document' be present. Specifically, it can contain a top-level "META-INF" directory and a "META-INF/sca-contribution.xml" file and there can also be an optional "META-INF/sca-contribution-generated.xml" file in the package. SCA defined artifacts as well as non-SCA defined artifacts such as object files, WSDL definition, Java classes can be present anywhere in the ZIP archive,
A up to date definition of the ZIP file format is published by PKWARE in HYPERLINK \l "Ref12" an Application Note on the .ZIP file format [12].
Installed Contribution
As noted in the section above, the contents of a contribution do not need to be modified in order to install and use it within a domain. An installed contribution is a contribution with all of the associated information necessary in order to execute deployable composites within the contribution.
An installed contribution is made up of the following things:
Contribution Packaging the contribution that will be used as the starting point for resolving all references
Contribution base URI
Dependent contributions: a set of snapshots of other contributions that are used to resolve the import statements from the root composite and from other dependent contributions
Dependent contributions might or might not be shared with other installed contributions.
When the snapshot of any contribution is taken is implementation defined, ranging from the time the contribution is installed to the time of execution
Deployment-time composites. These are composites that are added into an installed contribution after it has been deployed. This makes it possible to provide final configuration and access to implementations within a contribution without having to modify the contribution. These are optional, as composites that already exist within the contribution can also be used for deployment.
Installed contributions provide a context in which to resolve qualified names (e.g. QNames in XML, fully qualified class names in Java).
If multiple dependent contributions have exported definitions with conflicting qualified names, the algorithm used to determine the qualified name to use is implementation dependent. REF ASM12007 \h Implementations of SCA MAY also generate an error if there are conflicting names exported from multiple contributions. [ASM12007]
Installed Artifact URIs
When a contribution is installed, all artifacts within the contribution are assigned URIs, which are constructed by starting with the base URI of the contribution and adding the relative URI of each artifact (recalling that SCA requires that any packaging format be able to offer up its artifacts in a single hierarchy).
Operations for Contributions
SCA Domains provide the following conceptual functionality associated with contributions (meaning the function might not be represented as addressable services and also meaning that equivalent functionality might be provided in other ways). The functionality is optional meaning that some REF ASM12008 \h SCA runtimes MAY choose not to provide the contribution functions functionality in any way. [ASM12008]
install Contribution & update Contribution
Creates or updates an installed contribution with a supplied root contribution, and installed at a supplied base URI. A supplied dependent contribution list ( elements) specifies the contributions that should be used to resolve the dependencies of the root contribution and other dependent contributions. These override any dependent contributions explicitly listed via the location attribute in the import statements of the contribution.
SCA follows the simplifying assumption that the use of a contribution for resolving anything also means that all other exported artifacts can be used from that contribution. Because of this, the dependent contribution list is just a list of installed contribution URIs. There is no need to specify what is being used from each one.
Each dependent contribution is also an installed contribution, with its own dependent contributions. By default these dependent contributions of the dependent contributions (which we will call indirect dependent contributions) are included as dependent contributions of the installed contribution. However, if a contribution in the dependent contribution list exports any conflicting definitions with an indirect dependent contribution, then the indirect dependent contribution is not included (i.e. the explicit list overrides the default inclusion of indirect dependent contributions). Also, REF ASM12009 \h if there is ever a conflict between two indirect dependent contributions, then the conflict MUST be resolved by an explicit entry in the dependent contribution list. [ASM12009]
Note that in many cases, the dependent contribution list can be generated. In particular, if the creator of a domain is careful to avoid creating duplicate definitions for the same qualified name, then it is easy for this list to be generated by tooling.
add Deployment Composite & update Deployment Composite
Adds or updates a deployment composite using a supplied composite ("composite by value" a data structure, not an existing resource in the domain) to the contribution identified by a supplied contribution URI. The added or updated deployment composite is given a relative URI that matches the @name attribute of the composite, with a .composite suffix. Since all composites must run within the context of a installed contribution (any component implementations or other definitions are resolved within that contribution), this functionality makes it possible for the deployer to create a composite with final configuration and wiring decisions and add it to an installed contribution without having to modify the contents of the root contribution.
Also, in some use cases, a contribution might include only implementation code (e.g. PHP scripts). It is then possible for those to be given component names by a (possibly generated) composite that is added into the installed contribution, without having to modify the packaging.
remove Contribution
Removes the deployed contribution identified by a supplied contribution URI.
Use of Existing (non-SCA) Mechanisms for Resolving Artifacts
For certain types of artifact, there are existing and commonly used mechanisms for referencing a specific concrete location where the artifact can be resolved.
Examples of these mechanisms include:
For WSDL files, the @wsdlLocation attribute is a hint that has a URI value pointing to the place holding the WSDL itself.
For XSDs, the @schemaLocation attribute is a hint which matches the namespace to a URI where the XSD is found.
Note: In neither of these cases is the runtime obliged to use the location hint and the URI does not have to be dereferenced.
SCA permits the use of these mechanisms REF ASM12010 \h Where present, non-SCA artifact resolution mechanisms MUST be used by the SCA runtime in precendence to the SCA mechanisms. [ASM12010] However, use of these mechanisms is discouraged because tying assemblies to addresses in this way makes the assemblies less flexible and prone to errors when changes are made to the overall SCA Domain.
Note: REF ASM12011 \h If one of the non-SCA artifact resolution mechanisms is present, but there is a failure to find the resource indicated when using the mechanism (eg the URI is incorrect or invalid, say) the SCA runtime MUST raise an error and MUST NOT attempt to use SCA resolution mechanisms as an alternative. [ASM12011]
Domain-Level Composite
The domain-level composite is a virtual composite, in that it is not defined by a composite definition document. Rather, it is built up and modified through operations on the domain. However, in other respects it is very much like a composite, since it contains components, wires, services and references.
REF ASM12012 \h The value of @autowire for the logical domain composite MUST be autowire="false". [ASM12012]
REF ASM12013 \h \* MERGEFORMAT For components at the Domain level, with References for which @autowire="true" applies, the behaviour of the SCA runtime for a given Domain MUST take ONE of the 3 following forms:
1) The SCA runtime MAY disallow deployment of any components with autowire References. In this case, the SCA runtime MUST generate an exception at the point where the component is deployed.
2) The SCA runtime MAY evaluate the target(s) for the reference at the time that the component is deployed and not update those targets when later deployment actions occur.
3) The SCA runtime MAY re-evaluate the target(s) for the reference dynamically as later deployment actions occur resulting in updated reference targets which match the new Domain configuration. How the new configuration of the reference takes place is described by the relevant client and implementation specifications.
[ASM12013]
The abstract domain-level functionality for modifying the domain-level composite is as follows, although a runtime may supply equivalent functionality in a different form:
add To Domain-Level Composite
This functionality adds the composite identified by a supplied URI to the Domain Level Composite. The supplied composite URI must refer to a composite within a installed contribution. The composite's installed contribution determines how the composites artifacts are resolved (directly and indirectly). The supplied composite is added to the domain composite with semantics that correspond to the domain-level composite having an statement that references the supplied composite. All of the composites components become top-level components and the services become externally visible services (eg. they would be present in a WSDL description of the domain).
remove From Domain-Level Composite
Removes from the Domain Level composite the elements corresponding to the composite identified by a supplied composite URI. This means that the removal of the components, wires, services and references originally added to the domain level composite by the identified composite.
get Domain-Level Composite
Returns a definition that has an line for each composite that had been added to the domain level composite. It is important to note that, in dereferencing the included composites, any referenced artifacts must be resolved in terms of that installed composite.
get QName Definition
In order to make sense of the domain-level composite (as returned by get Domain-Level Composite), it must be possible to get the definitions for named artifacts in the included composites. This functionality takes the supplied URI of an installed contribution (which provides the context), a supplied qualified name of a definition to look up, and a supplied symbol space (as a QName, eg wsdl:PortType). The result is a single definition, in whatever form is appropriate for that definition type.
Note that this, like all the other domain-level operations, is a conceptual operation. Its capabilities should exist in some form, but not necessarily as a service operation with exactly this signature.
Conformance
The XML schema available at the namespace URI, defined by this specification, is considered to be authoritative and takes precedence over the XML Schema defined in the appendix of this document.
REF ASM10001 \h An SCA runtime MUST reject a composite file that does not conform to the sca-core.xsd schema [ASM10001]
Pseudo Schema
ComponentType
*
*
?
+
*
*
?
+
*
default-property-value?
?
Composite
*
*
?
*
?
+
*
?
*
?
+
*
default-property-value?
*
?
*
?
*
?
+
*
[+ | xs:any+]?
*
?
*
?
+
*
XML Schemas
sca.xsd
sca-core.xsd
sca-binding-sca.xsd
sca-interface-java.xsd
sca-interface-wsdl.xsd
sca-implementation-java.xsd
sca-implementation-composite.xsd
sca-definitions.xsd
sca-binding-webservice.xsd
Is described in HYPERLINK \l "Ref9" the SCA Web Services Binding specification [9]
sca-binding-jms.xsd
Is described in HYPERLINK \l "Ref11" the SCA JMS Binding specification [11]
sca-policy.xsd
Is described in HYPERLINK \l "Ref10" the SCA Policy Framework specification [10]
sca-contribution.xsd
SCA Concepts
Binding
Bindings are used by services and references. References use bindings to describe the access mechanism used to call the service to which they are wired. Services use bindings to describe the access mechanism(s) that clients should use to call the service.
SCA supports multiple different types of bindings. Examples include SCA service, Web service, stateless session EJB, data base stored procedure, EIS service. SCA provides an extensibility mechanism by which an SCA runtime can add support for additional binding types.
Component
SCA components are configured instances of SCA implementations, which provide and consume services. SCA allows many different implementation technologies such as Java, BPEL, C++. SCA defines an extensibility mechanism that allows you to introduce new implementation types. The current specification does not mandate the implementation technologies to be supported by an SCA run-time, vendors may choose to support the ones that are important for them. A single SCA implementation may be used by multiple Components, each with a different configuration.
The Component has a reference to an implementation of which it is an instance, a set of property values, and a set of service reference values. Property values define the values of the properties of the component as defined by the components implementation. Reference values define the services that resolve the references of the component as defined by its implementation. These values can either be a particular service of a particular component, or a reference of the containing composite.
Service
SCA services are used to declare the externally accessible services of an implementation. For a composite, a service is typically provided by a service of a component within the composite, or by a reference defined by the composite. The latter case allows the republication of a service with a new address and/or new bindings. The service can be thought of as a point at which messages from external clients enter a composite or implementation.
A service represents an addressable set of operations of an implementation that are designed to be exposed for use by other implementations or exposed publicly for use elsewhere (eg public Web services for use by other organizations). The operations provided by a service are specified by an Interface, as are the operations required by the service client (if there is one). An implementation may contain multiple services, when it is possible to address the services of the implementation separately.
A service may be provided as SCA remote services, as Web services, as stateless session EJBs, as EIS services, and so on. Services use bindings to describe the way in which they are published. SCA provides an extensibility mechanism that makes it possible to introduce new binding types for new types of services.
Remotable Service
A Remotable Service is a service that is designed to be published remotely in a loosely-coupled SOA architecture. For example, SCA services of SCA implementations can define implementations of industry-standard web services. Remotable services use pass-by-value semantics for parameters and returned results.A service is remotable if it is defined by a WSDL port type or if it defined by a Java interface marked with the @Remotable annotation.
Local Service
Local services are services that are designed to be only used locally by other implementations that are deployed concurrently in a tightly-coupled architecture within the same operating system process.
Local services may rely on by-reference calling conventions, or may assume a very fine-grained interaction style that is incompatible with remote distribution. They may also use technology-specific data-types.
Currently a service is local only if it defined by a Java interface not marked with the @Remotable annotation.
Reference
SCA references represent a dependency that an implementation has on a service that is supplied by some other implementation, where the service to be used is specified through configuration. In other words, a reference is a service that an implementation may call during the execution of its business function. References are typed by an interface.
For composites, composite references can be accessed by components within the composite like any service provided by a component within the composite. Composite references can be used as the targets of wires from component references when configuring Components.
A composite reference can be used to access a service such as: an SCA service provided by another SCA composite, a Web service, a stateless session EJB, a data base stored procedure or an EIS service, and so on. References use bindings to describe the access method used to their services. SCA provides an extensibility mechanism that allows the introduction of new binding types to references.
Implementation
An implementation is concept that is used to describe a piece of software technology such as a Java class, BPEL process, XSLT transform, or C++ class that is used to implement one or more services in a service-oriented application. An SCA composite is also an implementation.
Implementations define points of variability including properties that can be set and settable references to other services. The points of variability are configured by a component that uses the implementation. The specification refers to the configurable aspects of an implementation as its componentType.
Interface
Interfaces define one or more business functions. These business functions are provided by Services and are used by components through References. Services are defined by the Interface they implement. SCA currently supports a number of interface type systems, for example:
Java interfaces
WSDL portTypes
C, C++ header files
SCA also provides an extensibility mechanism by which an SCA runtime can add support for additional interface type systems.
Interfaces may be bi-directional. A bi-directional service has service operations which must be provided by each end of a service communication this could be the case where a particular service requires a callback interface on the client, which is calls during the process of handing service requests from the client.
Composite
An SCA composite is the basic unit of composition within an SCA Domain. An SCA Composite is an assembly of Components, Services, References, and the Wires that interconnect them. Composites can be used to contribute elements to an SCA Domain.
A composite has the following characteristics:
It may be used as a component implementation. When used in this way, it defines a boundary for Component visibility. Components may not be directly referenced from outside of the composite in which they are declared.
It can be used to define a unit of deployment. Composites are used to contribute business logic artifacts to an SCA domain.
Composite inclusion
One composite can be used to provide part of the definition of another composite, through the process of inclusion. This is intended to make team development of large composites easier. Included composites are merged together into the using composite at deployment time to form a single logical composite.
Composites are included into other composites through elements in the using composite. The SCA Domain uses composites in a similar way, through the deployment of composite files to a specific location.
Property
Properties allow for the configuration of an implementation with externally set data values. The data value is provided through a Component, possibly sourced from the property of a containing composite.
Each Property is defined by the implementation. Properties may be defined directly through the implementation language or through annotations of implementations, where the implementation language permits, or through a componentType file. A Property can be either a simple data type or a complex data type. For complex data types, XML schema is the preferred technology for defining the data types.
Domain
An SCA Domain represents a set of Services providing an area of Business functionality that is controlled by a single organization. As an example, for the accounts department in a business, the SCA Domain might cover all finance-related functions, and it might contain a series of composites dealing with specific areas of accounting, with one for Customer accounts, another dealing with Accounts Payable.
A domain specifies the instantiation, configuration and connection of a set of components, provided via one or more composite files. The domain, like a composite, also has Services and References. Domains also contain Wires which connect together the Components, Services and References.
Wire
SCA wires connect service references to services.
Within a composite, valid wire sources are component references and composite services. Valid wire targets are component services and composite references.
When using included composites, the sources and targets of the wires dont have to be declared in the same composite as the composite that contains the wire. The sources and targets can be defined by other included composites. Targets can also be external to the SCA domain.
Conformance Items
This section contains a list of conformance items for the SCA Assembly specification.
Conformance IDDescription REF R_ASM10001 \h [ASM10001]An SCA runtime MUST reject a composite file that does not conform to the sca-core.xsd schema. REF R_ASM40002 \h [ASM40002]If present, the @constrainingType attribute of a element MUST reference a element in the Domain through its QName. REF R_ASM40003 \h [ASM40003]The @name attribute of a child element of a MUST be unique amongst the service elements of that . REF R_ASM40004 \h [ASM40004]The @name attribute of a child element of a MUST be unique amongst the reference elements of that . REF R_ASM40005 \h [ASM40005]The @name attribute of a child element of a MUST be unique amongst the property elements of that . REF R_ASM40006 \h [ASM40006]If @wiredByImpl is set to "true", then any reference targets configured for this reference MUST be ignored by the runtime. REF R_ASM40007 \h [ASM40007]The value of the property @type attribute MUST be the QName of an XML schema type. REF R_ASM40008 \h [ASM40008]The value of the property @element attribute MUST be the QName of an XSD global element. REF R_ASM40009 \h [ASM40009]The SCA runtime MUST ensure that any implementation default property value is replaced by a value for that property explicitly set by a component using that implementation. REF R_ASM50001 \h [ASM50001] REF ASM40003 \h The @name attribute of a child element of a MUST be unique amongst the service elements of that . REF R_ASM50002 \h [ASM50002]The @name attribute of a service element of a MUST be unique amongst the service elements of that REF R_ASM50003 \h [ASM50003]The @name attribute of a service element of a MUST match the @name attribute of a service element of the componentType of the child element of the component. REF R_ASM50004 \h [ASM50004] If a element has an interface subelement specified, the interface MUST provide a compatible subset of the interface declared on the componentType of the implementation REF R_ASM50005 \h [ASM50005] If no binding elements are specified for the service, then the bindings specified for the equivalent service in the componentType of the implementation MUST be used, but if the componentType also has no bindings specified, then MUST be used as the binding. If binding elements are specified for the service, then those bindings MUST be used and they override any bindings specified for the equivalent service in the componentType of the implementation. REF R_ASM50006 \h [ASM50006] If the callback element is present and contains one or more binding child elements, then those bindings MUST be used for the callback. REF R_ASM50007 \h [ASM50007] REF ASM50002 \h The @name attribute of a service element of a MUST be unique amongst the service elements of that REF R_ASM50008 \h [ASM50008]The @name attribute of a reference element of a MUST match the @name attribute of a reference element of the componentType of the child element of the component. REF R_ASM50009 \h [ASM50009]The value of multiplicity for a component reference MUST only be equal or further restrict any value for the multiplicity of the reference with the same name in the componentType of the implementation, where further restriction means 0..n to 0..1 or 1..n to 1..1. REF R_ASM50010 \h [ASM50010]If @wiredByImpl="true" is set for a reference, then the reference MUST NOT be wired statically within a composite, but left unwired. REF R_ASM50011 \h [ASM50011]If an interface is declared for a component reference it MUST provide a compatible superset of the interface declared for the equivalent reference in the componentType of the implementation, i.e. provide the same operations or a superset of the operations defined by the implementation for the reference. REF R_ASM50012 \h [ASM50012] If no binding elements are specified for the reference, then the bindings specified for the equivalent reference in the componentType of the implementation MUST be used, but if the componentType also has no bindings specified, then MUST be used as the binding. If binding elements are specified for the reference, then those bindings MUST be used and they override any bindings specified for the equivalent reference in the componentType of the implementation. REF R_ASM50013 \h [ASM50013]If @wiredByImpl="true", other methods of specifying the target service MUST NOT be used. REF R_ASM50014 \h [ASM50014]If @autowire="true", the autowire procedure MUST only be used if no target is identified by any of the other ways listed above. It is not an error if @autowire="true" and a target is also defined through some other means, however in this case the autowire procedure MUST NOT be used. REF R_ASM50015 \h [ASM50015]If a binding element has a value specified for a target service using its @uri attribute, the binding element MUST NOT identify target services using binding specific attributes or elements. REF R_ASM50016 \h [ASM50016]It is possible that a particular binding type MAY require that the address of a target service uses more than a simple URI. In such cases, the @uri attribute MUST NOT be used to identify the target service - instead, binding specific attributes and/or child elements must be used. REF R_ASM50017 \h [ASM50017]When the reference has a value specified in its @target attribute, one of the child binding elements MUST be used on each wire created by the @target attribute, or the sca binding, if no binding is specified. REF R_ASM50018 \h [ASM50018]A reference with multiplicity 0..1 or 0..n MAY have no target service defined. REF R_ASM50019 \h [ASM50019]A reference with multiplicity 0..1 or 1..1 MUST NOT have more that one target service defined. REF R_ASM50020 \h [ASM50020]A reference with multiplicity 1..1 or 1..n MUST have at least one target service defined. REF R_ASM50021 \h [ASM50021]A reference with multiplicity 0..n or 1..n MAY have one or more target services defined. REF R_ASM50022 \h [ASM50022]Where it is detected that the rules for the number of target services for a reference have been violated, either at deployment or at execution time, an SCA Runtime MUST generate an error no later than when the reference is invoked by the component implementation. REF R_ASM50023 \h [ASM50023]Some reference multiplicity errors can be detected at deployment time. In these cases, an error SHOULD be generated by the SCA runtime at deployment time. REF R_ASM50024 \h [ASM50024]Other reference multiplicity errors can only be checked at runtime. In these cases, the SCA runtime MUST generate an error no later than when the reference is invoked by the component implementation. REF R_ASM50025 \h [ASM50025]Where a component reference is promoted by a composite reference, the promotion MUST be treated from a multiplicity perspective as providing 0 or more target services for the component reference, depending upon the further configuration of the composite reference. These target services are in addition to any target services identified on the component reference itself, subject to the rules relating to multiplicity. REF R_ASM50026 \h [ASM50026]If a reference has a value specified for one or more target services in its @target attribute, the child binding elements of that reference MUST NOT identify target services using the @uri attribute or using binding specific attributes or elements. REF R_ASM50027 \h [ASM50027]If the @value attribute of a component property element is declared, the type of the property MUST be an XML Schema simple type and the @value attribute MUST contain a single value of that type. REF R_ASM50028 \h [ASM50028]If the value subelement of a component property is specified, the type of the property MUST be an XML Schema simple type or an XML schema complex type. REF R_ASM50029 \h [ASM50029]If a component property value is declared using a child element of the element, the type of the property MUST be an XML Schema global element and the declared child element MUST be an instance of that global element. REF R_ASM50030 \h [ASM50030]A element MUST NOT contain two subelements with the same value of the @name attribute. REF R_ASM50031 \h [ASM50031]The name attribute of a component property MUST match the name of a property element in the component type of the component implementation. REF R_ASM50032 \h [ASM50032If a property is single-valued, the subelement MUST NOT occur more than once. REF R_ASM50033 \h [ASM50033]A property subelement MUST NOT be used when the @value attribute is used to specify the value for that property. REF R_ASM60001 \h [ASM60001]A composite name must be unique within the namespace of the composite. REF R_ASM60002 \h [ASM60002]@local="true" for a composite means that all the components within the composite MUST run in the same operating system process. REF R_ASM60003 \h [ASM60003]The name of a composite element MUST be unique across all the composite services in the composite. REF R_ASM60004 \h [ASM60004]A composite element's promote attribute MUST identify one of the component services within that composite. REF R_ASM60005 \h [ASM60005] If a composite service interface is specified it must be the same or a compatible subset of the interface provided by the promoted component service, i.e. provide a subset of the operations defined by the component service. REF R_ASM60006 \h [ASM60006]The name of a composite element MUST be unique across all the composite references in the composite. REF R_ASM60007 \h [ASM60007]Each of the URIs declared by a composite reference's @promote attribute MUST identify a component reference within the composite. REF R_ASM60008 \h [ASM60008]the interfaces of the component references promoted by a composite reference MUST be the same, or if the composite reference itself declares an interface then all the component reference interfaces must be compatible with the composite reference interface. Compatible means that the component reference interface is the same or is a strict subset of the composite reference interface. REF R_ASM60009 \h [ASM60009]the intents declared on a composite reference and on the component references which it promoites MUST NOT be mutually exclusive. REF R_ASM60010 \h [ASM60010]If any intents in the set which apply to a composite reference are mutually exclusive then the SCA runtime MUST raise an error. REF R_ASM60011 \h [ASM60011]The value specified for the multiplicity attribute of a composite reference MUST be compatible with the multiplicity specified on each of the promoted component references, i.e. the multiplicity has to be equal or further restrict. So multiplicity 0..1 can be used where the promoted component reference has multiplicity 0..n, multiplicity 1..1 can be used where the promoted component reference has multiplicity 0..n or 1..n and multiplicity 1..n can be used where the promoted component reference has multiplicity 0..n., However, a composite reference of multiplicity 0..n or 1..n cannot be used to promote a component reference of multiplicity 0..1 or 1..1 respectively. REF R_ASM60012 \h [ASM60012] If a composite reference has an interface specified, it MUST provide an interface which is the same or which is a compatible superset of the interface(s) declared by the promoted component reference(s), i.e. provide a superset of the operations in the interface defined by the component for the reference. REF R_ASM60013 \h [ASM60013]If no interface is declared on a composite reference, the interface from one of its promoted component references is used, which MUST be the same as or a compatible superset of the interface(s) declared by the promoted component reference(s). REF R_ASM60014 \h [ASM60014]The name attribute of a composite property MUST be unique amongst the properties of the same composite. REF R_ASM60015 \h [ASM60015]the source interface and the target interface of a wire MUST either both be remotable or else both be local REF R_ASM60016 \h [ASM60016]the operations on the target interface of a wire MUST be the same as or be a superset of the operations in the interface specified on the source REF R_ASM60017 \h [ASM60017]compatibility between the source interface and the target interface for a wire for the individual operations is defined as compatibility of the signature, that is operation name, input types, and output types MUST be the same. REF R_ASM60018 \h [ASM60018]the order of the input and output types for operations in the source interface and the target interface of a wire also MUST be the same. REF R_ASM60019 \h [ASM60019]the set of Faults and Exceptions expected by each operation in the source interface MUST be the same or be a superset of those specified by the target interface. REF R_ASM60020 \h [ASM60020]other specified attributes of the source interface and the target interface of a wire MUST match, including Scope and Callback interface REF R_ASM60021 \h [ASM60021]For the case of an un-wired reference with multiplicity 1..1 or 1..n the deployment process provided by an SCA runtime SHOULD issue a warning. REF R_ASM60022 \h [ASM60022] For each component reference for which autowire is enabled, the the SCA runtime MUST search within the composite for target services which are compatible with the reference. REF R_ASM60023 \h [ASM60023]the target service interface MUST be a compatible superset of the reference interface when using autowire to wire a reference (as defined in HYPERLINK \l "_Wire_2" the section on Wires) REF R_ASM60024 \h [ASM60024]the intents, and policies applied to the service MUST be compatible with those on the reference when using autowire to wire a reference so that wiring the reference to the service will not cause an error due to policy mismatch REF R_ASM60025 \h [ASM60025]for an autowire reference with multiplicity 0..1 or 1..1, the SCA runtime MUST wire the reference to one of the set of valid target services chosen from the set in a runtime-dependent fashion REF R_ASM60026 \h [ASM60026]for an autowire reference with multiplicity 0..n or 1..n, the reference MUST be wired to all of the set of valid target services REF R_ASM60027 \h [ASM60027]for an autowire reference with multiplicity 0..1 or 0..n, if the SCA runtime finds no valid target service, there is no problem no services are wired and the SCA runtime MUST NOT raise an error REF R_ASM60028 \h [ASM60028]for an autowire reference with multiplicity 1..1 or 1..n, if the SCA runtime finds no valid target services an error MUST be raised by the SCA runtime since the reference is intended to be wired REF R_ASM60030 \h [ASM60030]The @name attribute of an element MUST contain the QName of a composite in the SCA Domain. REF R_ASM60031 \h [ASM60031]The SCA runtime MUST raise an error if the composite resulting from the inclusion of one composite into another is invalid. REF R_ASM70001 \h [ASM70001]The constrainingType specifies the services, references and properties that MUST be implemented by the implementation of the component to which the constrainingType is attached. REF R_ASM70002 \h [ASM70002]If the configuration of the component or its implementation do not conform to the constrainingType specified on the component element, the SCA runtime MUST raise an error. REF R_ASM70003 \h [ASM70003]The name attribute of the constraining type MUST be unique in the SCA domain. REF R_ASM70004 \h [ASM70004]When an implementation is constrained by a constrainingType its component type MUST contain all the services, references and properties specified in the constrainingType. REF R_ASM70005 \h [ASM70005]An implementation MAY contain additional services, additional optional references (multiplicity 0..1 or 0..n) and additional optional properties beyond those declared in the constraining type, but MUST NOT contain additional non-optional references (multiplicity 1..1 or 1..n) or additional non-optional properties (a property with mustSupply=true). REF R_ASM70006 \h [ASM70006] Additional services, references and properties provided by the implementation which are not declared in the constrainingType associated with a component MUST NOT be configured in any way by the containing composite. REF R_ASM70007 \h [ASM70007] A component or implementation can use a qualified form of an intent specified in unqualified form in the constrainingType, but if the constrainingType uses the qualified form of an intent, then the component or implementation MUST also use the qualified form, otherwise there is an error. REF R_ASM80001 \h [ASM80001]The interface.wsdl @interface attribute MUST reference a portType of a WSDL 1.0 document OR an interface element of a WSDL 2.0 document. REF R_ASM80002 \h [ASM80002]Remotable service Interfaces MUST NOT make use of method or operation overloading. REF R_ASM80003 \h [ASM80003]If a remotable service is called locally or remotely, the SCA container MUST ensure sure that no modification of input messages by the service or post-invocation modifications to return messages are seen by the caller. REF R_ASM80004 \h [ASM80004]If a reference is defined using a bidirectional interface element, the client component implementation using the reference calls the referenced service using the interface. The client MUST provide an implementation of the callback interface. REF R_ASM80005 \h [ASM80005]Either both interfaces of a bidirectional service MUST be remotable, or both MUST be local. A bidirectional service MUST NOT mix local and remote services. REF R_ASM80006 \h [ASM80006]Where a service or a reference has a conversational interface, the conversational intent MUST be attached either to the interface itself, or to the service or reference using the interface. REF R_ASM80007 \h [ASM80007]Once an operation marked with endsConversation has been invoked, any subsequent attempts to call an operation or a callback operation associated with the same conversation MUST generate a sca:ConversationViolation fault. REF R_ASM80008 \h [ASM80008]Any service or reference that uses an interface marked with required intents MUST implicitly add those intents to its own @requires list. REF R_ASM90001 \h [ASM90001]For a binding of a reference the URI attribute defines the target URI of the reference. This MUST be either the componentName/serviceName for a wire to an endpoint within the SCA domain, or the accessible address of some service endpoint either inside or outside the SCA domain (where the addressing scheme is defined by the type of the binding). REF R_ASM90002 \h [ASM90002]When a service or reference has multiple bindings, only one binding can have the default name value; all others must have a name value specified that is unique within the service or reference. REF R_ASM90003 \h [ASM90003]If a reference has any bindings they MUST be resolved which means that each binding MUST include a value for the @URI attribute or MUST otherwise specify an endpoint. The reference MUST NOT be wired using other SCA mechanisms. REF R_ASM90004 \h [ASM90004]a wire target MAY be specified with a syntax of "componentName/serviceName/bindingName". REF R_ASM12001 \h [ASM12001]For any contribution packaging it MUST be possible to present the artifacts of the packaging to SCA as a hierarchy of resources based off of a single root REF R_ASM12002 \h [ASM12002]Within any contribution packaging A directory resource SHOULD exist at the root of the hierarchy named META-INF REF R_ASM12003 \h [ASM12003]Within any contribution packaging a document SHOULD exist directly under the META-INF directory named sca-contribution.xml which lists the SCA Composites within the contribution that are runnable. REF R_ASM12004 \h [ASM12004]Optionally, in the sca-contribution.xml file, additional elements MAY exist that list the namespaces of constructs that are needed by the contribution and which are be found elsewhere, for example in other contributions. REF R_ASM12005 \h [ASM12005]Where present, artifact-related or packaging-related mechanisms MUST be used to resolve artifact dependencies. REF R_ASM12006 \h [ASM12006] SCA requires that all runtimes MUST support the ZIP packaging format for contributions. REF R_ASM12007 \h [ASM12007]Implementations of SCA MAY also generate an error if there are conflicting names exported from multiple contributions. REF R_ASM12008 \h [ASM12008]SCA runtimes MAY choose not to provide the contribution functions functionality in any way. REF R_ASM12009 \h [ASM12009]if there is ever a conflict between two indirect dependent contributions, then the conflict MUST be resolved by an explicit entry in the dependent contribution list. REF R_ASM12010 \h [ASM12010] Where present, non-SCA artifact resolution mechanisms MUST be used by the SCA runtime in precendence to the SCA mechanisms. REF R_ASM12011 \h [ASM12011]If one of the non-SCA artifact resolution mechanisms is present, but there is a failure to find the resource indicated when using the mechanism (eg the URI is incorrect or invalid, say) the SCA runtime MUST raise an error and MUST NOT attempt to use SCA resolution mechanisms as an alternative. REF R_ASM12012 \h [ASM12012]The value of @autowire for the logical domain composite MUST be autowire="false". REF R_ASM12013 \h [ASM12013]For components at the Domain level, with References for which @autowire="true" applies, the behaviour of the SCA runtime for a given Domain MUST take ONE of the 3 following forms:
1) The SCA runtime MAY disallow deployment of any components with autowire References. In this case, the SCA runtime MUST generate an exception at the point where the component is deployed.
2) The SCA runtime MAY evaluate the target(s) for the reference at the time that the component is deployed and not update those targets when later deployment actions occur.
3) The SCA runtime MAY re-evaluate the target(s) for the reference dynamically as later deployment actions occur resulting in updated reference targets which match the new Domain configuration. How the new configuration of the reference takes place is described by the relevant client and implementation specifications.
Acknowledgements
The following individuals have participated in the creation of this specification and are gratefully acknowledged:
Participants: MACROBUTTON
MACROBUTTON NoMacro [Participant Name, Affiliation | Individual Member]
MACROBUTTON NoMacro [Participant Name, Affiliation | Individual Member]
Non-Normative Text
Revision History
MACROBUTTON NoMacro [optional; should not be included in OASIS Standards]
RevisionDateEditorChanges Made12007-09-24Anish KarmarkarApplied the OASIS template + related changes to the Submission22008-01-04Michael Beisiegelcomposite section
- changed order of subsections from property, reference, service to service, reference, property
- progressive disclosure of pseudo schemas, each section only shows what is described
- attributes description now starts with name : type (cardinality)
- child element description as list, each item starting with name : type (cardinality)
- added section in appendix to contain complete pseudo schema of composite
- moved component section after implementation section
- made the ConstrainingType section a top level section
- moved interface section to after constraining type section
component section
- added subheadings for Implementation, Service, Reference, Property
- progressive disclosure of pseudo schemas, each section only shows what is described
- attributes description now starts with name : type (cardinality)
- child element description as list, each item starting with name : type (cardinality)
implementation section
- changed title to Implementation and ComponentType
- moved implementation instance related stuff from implementation section to component implementation section
- added subheadings for Service, Reference, Property, Implementation
- progressive disclosure of pseudo schemas, each section only shows what is described
- attributes description now starts with name : type (cardinality)
- child element description as list, each item starting with name : type (cardinality)
- attribute and element description still needs to be completed, all implementation statements on services, references, and properties should go here
- added complete pseudo schema of componentType in appendix
- added Quick Tour by Sample section, no content yet
- added comment to introduction section that the following text needs to be added
"This specification is efined in terms of infoset and not XML 1.0, even though the spec uses XML 1.0/1.1 terminology. A mapping from XML to infoset (... link to infoset specification ...) is trivial and should be used for non-XML serializations."
32008-02-15Anish Karmarkar
Michael BeisiegelIncorporated resolutions from 2008 Jan f2f.
- issue 9
- issue 19
- issue 21
- issue 4
- issue 1A
- issue 27
- in Implementation and ComponentType
section added attribute and element
description for service, reference, and
property
- removed comments that helped understand
the initial restructuring for WD02
- added changes for issue 43
- added changes for issue 45, except the
changes for policySet and requires attribute
on property elements
- used the NS HYPERLINK "http://docs.oasis-open.org/ns/opencsa/sca/200712" http://docs.oasis-open.org/ns/opencsa/sca/200712
- updated copyright stmt
- added wordings to make PDF normative and xml schema at the NS uri autoritative42008-04-22Mike EdwardsEditorial tweaks for CD01 publication:
- updated URL for spec documents
- removed comments from published CD01 version
- removed blank pages from body of spec52008-06-30Anish Karmarkar
Michael BeisiegelIncorporated resolutions of issues: 3, 6, 14 (only as it applies to the component property element), 23, 25, 28, 25, 38, 39, 40, 42, 45 (except for adding @requires and @policySets to property elements), 57, 67, 68, 6962008-09-23Mike EdwardsEditorial fixes in response to Mark Combellack's review contained in email:
http://lists.oasis-open.org/archives/sca-assembly/200804/msg00089.html7 CD02 - Rev32008-11-18Mike EdwardsSpecification marked for conformance statements. New Appendix (D) added containing a table of all conformance statements. Mass of related minor editorial changes to remove the use of RFC2119 words where not appropriate.
sca-assembly-spec-cd01-rev3 18 November 2008
Copyright OASIS 2005, 2008. All Rights Reserved. Page PAGE 52 of NUMPAGES 129
MACROBUTTON NoMacro [document identifier] MACROBUTTON NoMacro [specification date]
Copyright OASIS 2005, 2008.All Rights Reserved. Page PAGE 1 of NUMPAGES 129
Issue 67
Issue 68
Issue 38
Issue 69 part 1
Issue 62 - mustSupply removed in accordance with the resolution.
Need to consider this as a normative statement
Need to raise an issue to remove this attribute from composite references since there is not code to do the wiring, unlike a component reference.
I think that this paragraph should be removed.
This psuedo-schema does not match the wording leading up to it...
Deliberately left unmarked due to the in-process issue that affects this section....
Issue 69 part 2
Issue 39
Issue 35
Didn't we get rid of this requirement?
This contradicts material below - is this the Issue 57 problem?
Issue 16 resolution affects this section a lot - left for the moment
Issue 39
Issue 28
Issue 39
Issue 28
Issue 57
Issue 57
Issue 42
Issue 40
f g r s u w x } W X Y Z
e
f
g
C D E ͽͭ͑́͝x h!nl 0J 5\ jG h!nl B*Uph h!nl 0J B* aJ ph j~
h!nl B*Uph j h!nl B*Uph j h!nl B*Uph
h!nl 0J j h!nl 0J Uh hT H hFhk h99 h!nl j h!nl U . J s Y
6
8 J f @&