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
