Good summary.
In addition to the various environment, there are two styles to launch an SCA
composite application:
1) The Tuscany runtime is not on the classpath and the SCA application doesn't
call any Tuscany APIs except the SCA Java annotations and APIs.
2) The Tuscany runtime (or a subset) is on the classpath and the SCA
application calls some sort of Tuscany APIs to bootstrap the Tuscany runtime.
Thanks,
Raymond
From: Simon Laws
Sent: Friday, January 09, 2009 7:13 AM
To: tuscany-dev
Subject: [2.x] [DISCUSS] Tuscany runtime launching
Some mechanisms we have used to date. Turns out to be quite long and I expect
there are more I have overlooked. Any help to orangize/rationlize this lot is
appreciated.
Tuscany User
==========
Someone who wants to use Tuscany to run a composite in a contribution they have
constructed. They will first have to get a Tuscany distribution
Download and unpack a distribution
Include mvn dependency on a distribution (I guess they could depend on
individual modules but it would be cleaner to have a distribution dependency)
Install the Tuscany Eclipse plugin
Get a container that embeds the Tuscany runtime
They treat Tuscany as a library and can run their contribution in a number of
ways
IDE(Eclipse)
Contribution only project
right click on composite (fires up the domain behind the scenes) -
depends on Tuscany Eclipse plugin
configure runAs to fire up the launcher from Tuscany library
Project with some kind of mainline that manually runs the lanucher, e.g.
JUnit
dependency on Tuscany library
dependency on just launcher modules and configure runAs with
$TUSCANY-HOME
Command line without writing a mainline
java -jar nodeLauncher.jar compositeURI contributionLocation
Run with direct reference to distribution directory
Specify location of launcher jar and distribution directory via
$TUSCANY-HOME (?)
Specify the required jars on the classpath either manually or with
tuscany-sca-manifest.jar
Command line with a mainline that fires up a node launcher
java MyClass.jar
Specify location of launcher jar and distribution directory via
$TUSCANY-HOME (?)
Specify the required jars on the classpath either manually or with
tuscany-sca-manifest.jar
There are some distinctions here as you may not want your client code
to share the same environment as the Tuscany runtime even though the two are
running in the same VM
Host-webapp, exploiting TuscanyServletFilter
Set up the servlet filter and include the Tuscany distribution in the
webapp itself
Container. With JEE support a user may want to contribute our composite as par
of a WAR, EAR etc
If the container embeds Tuscany then it's up to the container to ensure
that SCA contributions can be run
Mvn again assuming there is a mainline that fires up a node launcher
include a dependency on a Tuscany launcher distribtion
Domain
java -jar nodeLauncher.jar domain
and then add the contribution to the domain, configure a node and start it
OSGi
add all the tuscany jars and dependencies (PDETarget?) to your OSGi
environment
Need a bundle that will launch the domain, a node with a contribution or
some other service that launches a node
Tuscany Embedder
===============
Here the embedder wants to use the Tuscany API behind the launcher in order to
exploit some individual parts of the Tuscany code base. The embedder still
treats Tuscany as a library so they still need to download a distribution.
However the embedder must set up the classpath more explicitly
IDE(Eclipse)
Project with some kind of mainline that uses some Tuscany classes
dependency on Tuscany library
dependency on Tuscany modules from distribution. Set up manually.
dependency on Tuscany modules from local maven repo (mvn -Peclipse)
Command line with a mainline that uses some Tuscany classes
java MyClass.jar
Specify the required jars on the classpath either manually or with
tuscany-sca-manifest.jar
Mvn again with a mainline that uses some Tuscany classes
include a dependency on a Tuscany distribution
OSGi the embedder will construct a bundle which uses some Tuscany classes
add all the tuscany jars and dependencies (PDETarget?) to your OSGi
environment
Tuscany Developer
===============
A developer of the Tuscany infrastructure will first check out the source code
from svn. The developer may be acting as a user (running samples) or as an
embedder (running unit ot itests). Primarily a developer will use an IDE with
the tuscany modules loaded or a mvn compile.
IDE(Eclipse) - the important thing here is to have a dependency on the classes
in the Eclipse workspace so any changes are picked up as they happen without a
mvn compile.
Project with some kind of mainline that uses either launcher or other
Tuscany classes
dependency on Tuscany modules from workspace (mvn -Peclipse)
Mvn again with a mainline that uses either launcher or other Tuscany classes
include a dependency on a Tuscany distribution
Simon
