Tuscany Web Application based Integration with Geronimo

1. Introduction

Apache Tuscany is a java implementation of the emerging SCA specifications to simplify and realize service oriented architectures (SOA). Tuscany provides the capabilities to construct, assemble and deploy composite applications using SCA. Apache Geronimo is a fully certified Java EE 5 application server runtime.

Java Enterprise Edition (Java EE) is the standard for Java-based enterprise applications today. While it offers a rich set of technologies, it does not define important concepts that are inherently required in SOA such as:

• Extensibility of component implementation technologies
• Extensibility of transport and protocol abstractions
• A notion of cross-application/cross-network assembly and configuration

The Service Component Architecture on the other hand provides a standardized but extensible assembly language and methodology that can be layered on top of existing component models and runtimes.

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

• Consume SCA-exposed services from Java EE components using JEE programming model
• Consume session beans from SCA service components
• Expose SCA services as session beans or web services
• Use Session Beans as Service Component Implementations
• Inject SCA service references to web components to enable Web 2.0
• Expose enterprise applications into an SCA domain
• Use recursive SCA assembly in enterprise applications

The ability to deploy and run SCA composite applications with Geronimo will bring great value to both projects and communities. In this whitepaper, we will describe a simple web application based integration between Tuscany and Geronimo and walk through how to develop a web application using Apache Tuscany and deploy it to Apache Geronimo.

2. Staged Approach for Tuscany/Geronimo Integration

We propose to stage the Tuscany/Geronimo integrations based on the discussions on both mailing lists. Here is a summary of the basic ideas.

• Stage 1: Deploy tuscany runtime together with the application artifacts as a JEE web application
  We can start to develop composite applications using SCA programming model to assemble a few components, access existing web services or EJB session beans, 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.

• Stage 2: Integrate tuscany runtime as a plugin for Geronimo
  With this approach, SCA applications can be deployed to Geronimo via the Tuscany plugin. The Geronimo can then manage/run the SCA contributions and 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. The plugin should 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 as implementation types.
  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 the assembly and be wired against each other in the SCA domain.

The Stage 1 has been implemented in Tuscany since SCA Java 1.1-incubating release. There is a early prototype in Geronimo. It requires significant changes to align with the latest Tuscany. We need collaborate between both communities to grow the features over time.

3. Web Application based Tuscany/Geronimo Shadow Integration

In this scheme, we simply package the application artifcts together with the required tuscany jars and dependencies into standard web application archive (WAR). The WAR can be deployed to the most popular web containers such as Geronimo, Tomcat, Jetty and WebSphere. Some container-specific deployment descriptor files may be added.

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 use an existing sample in Tuscany to demonstrate the web application based approach. You can find it in Tuscany svn repo.

3.1 SCA composites

 
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

Automation of itests in web applications

6. Next steps

Tuscany Geronimo Integration Next Steps