ApacheCon US 2009 is just around the corner, and we are going to have several Apache Tuscany related sessions.

SCA, Java EE, Spring and Web 2.0 Come Together - Service assembly with Apache Tuscany SCA
Wed, 04 November 2009 11:00, by Luciano Resende

Apache Tuscany provides an easy-to-use open source services infrastructure for building, assembling, deploying and running SOA solutions based on the Service Component Architecture (SCA) specifications from OASIS. The Apache Tuscany project goes beyond the SCA specification and is an environment for innovative ideas around SOA, for example it extends SCA to work with web2.0 and OSGI. Apache Tuscany is integrated with other Apache technologies such as Tomcat, Axis2, Geronimo, BSF, Ode, XMLBeans and Abdera.This talk will provide a short overview of SCA and the Apache Tuscany project and will mainly focus on an enterprise integration example to demonstrate how to take advantage of SCA and Tuscany to describe, assemble and deploy an end-to-end SOA solution.

This talk is directed at those who are building distributed solutions from connected services and want to understand how SCA can help.

The presenters will use their experience of working with the Apache Tuscany project and its users to illustrate:
• Partitioning of the application into components and services
• Exploitation of a variety technologies to implement components including Java EE, Spring and Web2.0
• Use of different communication technologies such as web services, JSON-RPC
• Configuration of policy to control consistent quality of service across the distributed application
• Deployment to distributed runtimes with varying capabilities including Java EE containers, web browsers and command line JSE nodes

OSGi goes beyond service invocations in a single JVM with the introduction of RFC 119 - Distributed OSGi. It will enable an OSGi bundle deployed in a JVM to invoke a service (either OSGi or non-OSGi) in another JVM or process, potentially on a remote computer accessed via a network protocol. Meanwhile, an OSGi service deployed in another JVM or a non-OSGi program such as Web Service client, potentially on a remote computer, to find and access a service running in the "local" OSGi JVM (i.e. an OSGi deployment can accept service invocations from remote OSGi bundle or external environments). The distributed computing functionality is added to the OSGi programming model without additional APIs or concepts as the distribution layer will be mostly transparent to OSGi developers by configuration.

SCA (Service Component Architecture) provides a technology-neutral approach to abstract business logic into components and assemble them into composite applications. It greatly simplifies the component communications using declarative bindings. QoS requirements can be uniformly declared as SCA intents which can be mapped and realized using different stacks. SCA is a great fit to be a distribution provider for distributed OSGi.

Apache Tuscany is an open source project that implements the SCA specifications. It provides integrations of implementation types (such as Java, Scripting, BPEL, Spring, OSGi and JEE) and binding types (such as Web Service, JMS, EJB, CORBA, RMI, JSONRPC, and ATOM) as the infrastructure for SCA programming. The latest version of Tuscany runtime is fully built on top of OSGi as the foundation. We recently added the OSGi RFC 119 support.

In this session, we will teach you how to develop a distributed OSGi application to leverage the SCA capabilities using Apache Tuscany. A calculator scenario will be used to demonstrate the distributed OSGi service invocations using RMI and Web Service protocols. We will also explain how to model an OSGi bundle as an SCA component and configure the SCA composite to provide communications between services. The readers will understand the basic ideas behind distributed OSGi in the concrete example and the power of Tuscany SCA for service composition.

Apache Tuscany is an open source project that simplifies the development, deployment and management of distributed applications built as compositions of service components.It is based on the Service Component Architecture specifications being defined by the OASIS Open SCA Collaboration. Tuscany was built with a modular architecture, using a different approach from that of OSGi. In 2008 an effort was started to integrate Tuscany with OSGi. As part of this we undertook an investigation into how to apply OSGi modularity to the Tuscany runtime so that clean boundaries between modules are enforced and different versions of the same library can coexist.This involved analyzing the existing Tuscany modularity which turned up lots of interesting information about the linkages between the various sub-components. This understanding was then used to determine how to map Tuscany into a suitable form for use as OSGi bundles, including prototyping various levels of decomposition granularity. This presentation will share the experiences of analyzing and modularizing an existing project using OSGi. It will discuss what to expect when approaching modularizing existing projects, the tools (and it's caveats) for aiding analysis and also best practices for applying OSGi modularity. Beyond the OSGi enablement for the runtime, we are also going to cover how to integrate OSGi and SCA at the application level.

Read the original blog entry...