Tuscany Web Application based Integration with Geronimo

1. Introduction

Developing SOA based solutions can be very complex and expensive. Apache Tuscany provides a lightweight infrastructure which enables users to easily implement SOA based solutions or to use
their existing assets and align them with SOA principles which would support a business model that can extend and expand as business needs change.

Apache Tuscany implements SCA specifications that is being standardized at OASIS. Tuscany provides the capabilities to construct, assemble and deploy composite applications using SCA.

This white paper explains how Tuscany integrates with Apache Geronimo, a fully certified Java EE 5 application server runtime, to provide added value to users wanting to develop SOA solutions using Geronimo as a platform. The added values include:

• Extensibility of component implementation technologies
• Extensibility of transport and protocol abstractions
• A notion of cross-application/cross-network assembly and configuration
• Integration of SCA with existing or new EJB based applications

The following are a set of usage scenarios that both JEE and SCA developers could be interested in.

• Access SCA composites from Java EE components using JEE programming model
• Access session beans from SCA service components
• Expose SCA services as session beans or web services
• Include Session Beans in a single SCA composition by providing an SCA implementation for session beans.
• Inject SCA service references to web components to enable Web 2.0
• Expose enterprise applications into an SCA domain what does this mean?
• Use recursive SCA assembly in enterprise applications

In this whitepaper, we will describe an initial step taken to integrate Tuscany and Geronimo. It is assumed that you are familiar with Geronimo and Tuscany SCA. Here is the link to SCA user doc .

2. Staged Approach for Tuscany/Geronimo Integration

We had proposed to stage the Tuscany/Geronimo integration on the Geronimo/Tuscany mailing lists. Here is a summary of the basic ideas that were discussed.

• Stage 1: Deploy tuscany runtime together with the application artifacts as a JEE web application
  With this approach, we can develop composite applications using SCA programming model to assemble a few components, access existing web services or EJB session beans and expose SCA component services over various protocols such as Web Services, JSONRPC, Feed (ATOM and RSS). The web components such as Servlet, JSP can talk to the SCA aassembly. The SCA assembly can talk to existing services and can provide services for JEE programs to consume. can the word composite application be used instead of sca assembly?

• Stage 2: Integrate tuscany runtime as a plugin for Geronimo
  With this approach, SCA applications can be deployed to Geronimo via a Tuscany plugin. Geronimo can then manage/run the SCA composites. The Tuscany plugin also interacts with other containers in the Geronimo assembly such as Tomcat/Jetty, OpenEJB, ActiveMQ to provide various binding support for SCA services what does this mean?. The plugin could integrate with the QoSs such as Transaction and Security provided by Geronimo to support SCA intents/policies.

• Stage 3: Enable Geronimo JEE to support SCA composites which include JEE constructs
  The main objective to support the SCA JEE integration spec: http://www.osoa.org/download/attachments/1048948/SCA_JAVAEE_integration_v11.doc.
  With the SCA-enabled JEE, the application developers can use both the SCA and JEE programming model. Both SCA and JEE artifacts can participate in the assembly and be wired against each other in the SCA domain.

Stage 1 is now available in release 1.2 of Tuscany.

An initial prototype of stage 2 has been available in Tuscany since SCA Java 1.1-incubating release. Much more work is needed to re-align the plug-in to the latest release of Tuscany and to complete the work. Contributions are very welcome.

2. Set up Environment

Put links to SCA and Geronimo download. Which versions are needed.

3. Web Application based Tuscany/Geronimo - A "Shallow Integration"

Here we will cover the first step in integrating Tuscany with Geronimo which is running Tuscany as a webapp on top of Geronimo. This is now available in release 1.2 of Tuscany that can be downloaded from put link.

In this scheme,an SCA composite crated with Tuscany is packaged into a web applications archive (WAR) while including application artifacts and tuscany jars and dependencies. The WAR can be deployed to Geronimo or to other web containers such as Tomcat, Jetty and WebSphere. Some container-specific deployment descriptor files may be added. PLEASE CLARIFY

A tuscany provided servlet filter (org.apache.tuscany.sca.host.webapp.TuscanyServletFilter) is configured to startup/shutdown the Tuscany runtime when the web application is started or stopped. The tuscany filter is also responsible to dispatch HTTP requests to HTTP-based bindings such as Web Services, JSONRPC and Atom/RSS Feed. Figure 1 below shows how the tuscany servlet filter bridges web application to SCA.

As illustrated in Figure 2, there are a few important files or folders in the WAR:

• META-INF/sca-contribution.xml: Defines the deployable composites for a given contribution
• WEB-INF/web.xml: Configures the web application with a tuscany servlet filter
• WEB-INF/geronimo-web.xml: Configures the web application to provide geronimo-specific deployment options
• WEB-INF/lib: Contains all the required tuscany jars and their dependencies

2.1 web.xml

As shown below, we configure the web.xml with a Tuscany servlet filter which is responsible to dispatch HTTP requests to corresponding SCA service binding listeners.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

  <display-name>Apache Tuscany Calculator Web Service Sample</display-name>
    <filter>
        <filter-name>tuscany</filter-name>
        <filter-class>org.apache.tuscany.sca.host.webapp.TuscanyServletFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>tuscany</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

2.2 geronimo-web.xml

The most important setting in the geronimo-web.xml is inverse-classloading which ensures the tuscany and its dependency classes will be loaded from the WEB-INF/lib. It creates an isolated environment for the tuscany runtime without being interfered by other jars shipped by Geronimo (such as axis2).

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://geronimo.apache.org/xml/ns/j2ee/web-2.0"
    xmlns:d="http://geronimo.apache.org/xml/ns/deployment-1.2">
    <d:environment>
        <d:moduleId>
            <d:groupId>org.apache.tuscany.sca</d:groupId>
            <d:artifactId>sample-calculator-ws-webapp</d:artifactId>
            <d:version>1.2-incubating-SNAPSHOT</d:version>
            <d:type>war</d:type>
        </d:moduleId>
        <d:inverse-classloading />
    </d:environment>
</web-app>

3. The sample scenario

We will use a Tuscany sample called calcualtor to demonstrate how the Geronimo/Tuscany integration using web application approach works. You can find the calculatr sample in Tuscany svn repo.

3.1 SCA composites

Below is the picture for the calculator sample and the description of SCA composite file.

 
The  Calculator.composite is one such deployable sca composite and is defined as follows.

<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
           targetNamespace="http://sample"
           xmlns:sample="http://sample"
           name="Calculator">

    <component name="CalculatorServiceComponent">
		<implementation.java class="calculator.CalculatorServiceImpl"/>
        <reference name="addService" >
           <interface.java interface="calculator.AddService" />
            <binding.ws uri="http://localhost:8080/sample-calculator-ws-webapp/AddServiceComponent"/>
        </reference>
        <reference name="subtractService" target="SubtractServiceComponent"></reference>
        <reference name="multiplyService" target="MultiplyServiceComponent"></reference>
        <reference name="divideService" target="DivideServiceComponent"></reference>
    </component>

    <component name="AddServiceComponent">
        <implementation.java class="calculator.AddServiceImpl"/>
        <service name="AddService">
             <interface.java interface="calculator.AddService" />
            <binding.ws/>
        </service>
    </component>

    <component name="SubtractServiceComponent">
        <implementation.java class="calculator.SubtractServiceImpl"/>
    </component>

    <component name="MultiplyServiceComponent">
        <implementation.java class="calculator.MultiplyServiceImpl"/>
    </component>

    <component name="DivideServiceComponent">
        <implementation.java class="calculator.DivideServiceImpl"/>
    </component>

</composite>

3.2 sca-contribution.xml

META-INF/sca-contribution.xml defines the deployable composites for the given SCA contribution (the WAR in the webapp case). Tuscany servlet filter will bootstrap the SCA domain and deploy these composites.

<?xml version="1.0" encoding="UTF-8"?>
<contribution xmlns="http://www.osoa.org/xmlns/sca/1.0"
              targetNamespace="http://sample"
              xmlns:sample="http://sample">
   <deployable composite="sample:Calculator"/>
</contribution>

3.3 Web service binding

You can expose a SCA service as a web service or access external web services using SCA.

3.4 Talk to existing stateless session bean using binding.ejb

You can acccess existing stateless session bean using binding.ejb. Here is an example of the composite file.

<binding.ejb uri="corbaname:iiop:1.2@localhost:1050#VegetablesCatalogEJB" /> 

4. Devloping a Tuscany web application for Geronimo using Maven and Eclipse

4.1 Create an empty maven project for your web application

mvn archetype:generate

Select 18: internal -> maven-archetype-webapp (A simple Java web application) and provide the groupId/artifactId/version and package name.

You can use the calculator-ws-webapp sample as a template to configure the pom.xml.

mvn eclipse:eclipse

4.2 Import the project into Eclipse

In Eclipse, following the menu: File -> Import -> General --> Exising Projects into Workspace.

4.3. Configure the maven pom.xml to generate web.xml and geronimo-web.xml automatically

Tuscany provides a maven which can generate the WEB-INF/web.xml and WEB-IN/geronimo-web.xml automatically as part of the maven build. The following xml snippet shows
the usage.

<build>
    <plugins>
    <!-- Generate web-xml and geronimo deployment descriptor -->
        <plugin>
            <groupId>org.apache.tuscany.sca</groupId>
            <artifactId>tuscany-maven-web-junit</artifactId>
            <version>1.2-incubating-SNAPSHOT</version>
            <executions>
                <execution>
                    <id>generate-web-xml</id>
                    <configuration>
                        <geronimo>true</geronimo>
                    </configuration>
                    <phase>process-resources</phase>
                    <goals>
                        <goal>generate</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

5. Test automation with maven

Tuscany has a suite of tests called itests. We have modified the tests to enable running of web applications as part of the test suite.

Automation of itests in web applications

6. Next steps

Tuscany Geronimo Integration Next Steps