Table of Contents
1. Understanding Tuscany and SCA
Chapter 1. Introducing Tuscany and SCA
1.2. Designing a sample composite application
1.2.1. The travel-booking application
1.3. Implementing a composite application
1.3.1. A jump-start to building and running your first SCA component
1.3.2. Defining more complex components
1.3.3. Creating component implementations
1.3.4. Wiring components to form a composite application
1.3.5. Deploying a composite application using contributions
1.4. Working with other SOA technologies
1.4.2. Using SCA implementations
Chapter 2. Using SCA components
2.1. Implementing an SCA component
2.1.1. Choosing an implementation type
2.1.2. Configuring SCA components using component definitions
2.2. Using components to provide services
2.2.2. Interface definition in SCA
2.2.3. Configuring services in component definitions
2.2.4. Local and remotable interfaces
2.3. Connecting components using references and wires
2.4. Configuring components using properties
2.5. Enabling communication flexibility using bindings
Chapter 3. SCA composite applications
3.1. Running a composite application in a single process
3.2. Understanding the SCA domain
3.2.1. The domain as a contribution repository
3.2.2. The domain as a naming and visibility boundary
3.2.3. The domain as an execution environment
3.3. Running a distributed composite application
3.3.2. Installing contributions into the domain
3.3.3. Deploying composites for execution
3.3.4. Assigning composites to execution nodes
3.3.5. Creating and starting execution nodes
3.3.6. Running the domain manager from a saved configuration
3.4. Using SCA composites as application building blocks
3.4.1. Different ways of using SCA composites
3.4.2. Using composites as component implementations
Chapter 4. Service interaction patterns
4.1. Understanding the range of SCA service interaction patterns
4.4. Request response interaction
4.7. Conversational interaction
Chapter 5. Implementing components using the Java language
5.1. Defining a Java component implementation
5.2. Using SCA annotations in Java implementations
5.3. Services and references with Java interfaces
5.3.1. Identifying local and remote services
5.3.2. Implicit and explicit definition of component interfaces
5.3.3. Interface compatibility and mapping
5.5. Java component references
5.6. Java component properties
5.7. Java component instance creation and scope
5.7.1. Stateless, composite, and conversational scopes
5.7.2. Interacting with component instance creation and destruction
5.8.1. The credit card security callback scenario
5.8.2. Creating a bidirectional interface with the @Callback annotation
5.8.3. The service programming model for callbacks
5.8.4. The client programming model for callbacks
5.8.5. Getting the callback proxy from the request context
5.8.6. Using callable references to provide callback flexibility
5.9.1. Defining and controlling conversations in Java implementations
5.9.2. Starting, using, and stopping conversations using annotations
5.10. Passing SCA service references
5.10.1. A service reference–passing scenario
5.10.2. Retrieving service references
Chapter 6. Implementing components using other technologies
6.1. Implementing components using Spring
6.1.1. Using Spring services and references without SCA tags
6.1.2. Using Spring services and references with SCA tags
6.1.3. Setting Spring properties
6.2. Implementing components using BPEL
6.2.1. The structure of a BPEL process document
6.2.2. BPEL in Tuscany and SCA
6.2.3. Mapping WS-BPEL partner links to SCA services
6.3. Implementing components using scripts
6.3.1. BSF-based script implementations in Tuscany and SCA
6.3.2. Defining interfaces for script-based SCA services and references
6.3.3. Mapping between SCA services and scripts
6.3.4. Mapping between SCA references and scripts
Chapter 7. Connecting components using bindings
7.1. Introduction to SCA bindings
7.2. Demonstrating SCA bindings
7.3. Connecting component services with binding.sca
7.4. Connecting component services with web services
7.4.1. Exposing an SCA service as a web service
7.4.2. Accessing a web service using the SCA Web Services binding
7.4.3. Configuration options for the SCA Web Services binding
7.5. Connecting component services with CORBA
7.5.1. Exposing an SCA service as a CORBA service
7.5.2. Accessing a CORBA service using the SCA CORBA binding
7.6. Connecting component services with RMI
7.6.1. Exposing an SCA service as an RMI service
7.7. Connecting component services with JMS
7.7.1. Exposing an SCA service using JMS
7.7.2. Accessing a JMS service using the SCA JMS service binding
7.8.1. Exposing an SCA service as an EJB
Chapter 8. Web clients and Web 2.0
8.1. Servlets as SCA component implementations
8.1.1. Creating the currency converter user interface using a servlet
8.2. Writing web component implementations using JSPs
8.3. HTML pages as SCA component implementations
8.3.1. Using an HTML page for the TuscanySCATours user interface
8.4. Exposing file system resources
8.5. Exposing component services as Atom and RSS feeds
8.6. Referencing Atom and RSS feeds
Chapter 9. Data representation and transformation
9.1. Data exchange between SCA components
9.1.1. Using WSDL to describe the CreditCardPayment interface
9.2. Representing data within component implementations
9.2.1. Passing data to component references using JAXB objects
9.3. Describing data contracts within SCA compositions
9.3.1. Specifying contracts on the component type
9.3.2. Specifying contracts on component services and references
9.4.1. Converting the data coming from the browser from JSON to JAXB
9.4.2. Converting from JAXB to AXIOM in order to send a SOAP request
Chapter 10. Defining and applying policy
10.1. An overview of policy within an SCA domain
10.3. Using intents and policy sets for implementation policy
10.4. Using intents and policy sets for interaction policy
10.4.1. Adding interaction intents to the composite file
10.4.2. Adding interaction intents to the component implementation
10.4.3. Choosing a policy set to satisfy the intent at the service
10.4.4. Choosing a policy set to satisfy the intent at the reference
10.4.5. Running the payment example with authentication enabled
10.5. Other features of the SCA Policy Framework
3. Deploying Tuscany applications
Chapter 11. Running and embedding Tuscany
11.1. Understanding the Tuscany runtime environment
11.1.1. The SCA domain and Tuscany nodes
11.2. Running Tuscany standalone
11.3. Running Tuscany using APIs
11.4. Running Tuscany with web applications
11.4.1. Configuring WEB-INF/web.xml
11.5. Configuring distributed nodes
11.5.1. Defining the contents of the domain code repository
11.5.2. Specifying the deployed composites
11.5.3. Defining the nodes in the execution cloud
11.5.4. Configuring bindings for the nodes in the execution cloud
Chapter 12. A complete SCA application
12.1. Getting ready to run the application
12.2. Assembling the travel-booking application
12.2.1. The application user interface (fullapp-ui)
12.2.2. Coordinating the application (fullapp-coordination)
12.2.3. Partner services (fullapp-packagedtrip and bespoketrip)
12.2.4. Currency conversion (fullapp-currency)
12.3. The travel-booking application in a distributed domain
12.4. Hints and tips for building composite applications
12.4.1. Prototyping and then filling out
12.4.2. Application organization
12.4.3. Developing contributions in a team
12.4.4. Testing contributions in a single VM
4. Exploring the Tuscany runtime
Chapter 13. Tuscany runtime architecture
13.1. An overview of the Tuscany architecture
13.2. A structural perspective of the Tuscany architecture
13.2.1. Tuscany core functions
13.3. A behavioral perspective of the Tuscany architecture
13.3.1. Starting and stopping the Tuscany runtime
13.3.2. Loading SCA applications
13.3.3. Building SCA composites
13.3.4. Augmenting the composite with runtime artifacts
14.1. The high-level view of developing a Tuscany extension
14.2. Developing a POJO implementation type
14.2.1. Add the implementation.pojo XML schema
14.2.2. Adding implementation.pojo XML processing
14.2.3. Determining the component type for implementation.pojo
14.2.4. Controlling implementation.pojo invocation and lifecycle
14.2.5. The end-to-end picture for the POJO implementation type
14.3. Developing a new binding type
14.3.1. Adding the binding.echo XML schema
14.3.2. Adding the binding.echo XML processor
14.3.3. Controlling binding.echo invocation and lifecycle
A.1.1. Getting Tuscany’s prerequisites
A.1.2. Downloading and installing Tuscany
A.1.3. Testing the Tuscany installation
A.2. Installing the examples for this book
A.2.1. Downloading the travel sample
A.2.2. Setting the TUSCANY_HOME environment variable
A.2.3. Testing the travel sample installation
B.1. Support for OASIS Open CSA SCA standards
B.2. OSGi enablement for the Tuscany runtime
B.3. Enhanced SCA domain and node support