Page History

Topic
- Functional components that represent sets of coherent functions
Status
- Being discussed

Problem that we are trying to solve
Assist developers of applications that embed some level of Tuscany capability
(including tools, Tuscany itself and so on).

User
Embedders, such as the Tuscany-Geronimo integration code (or JBoss when
they come along).

Things to consider
These are probably not agreed by folk today - we have work to do here to
define these.

The split between these components needs careful thought. For example,
"Basic Web Services" might be packaged separately from "Web Services Security",
but for an end user, the step from using the first to using the second is
a trivial addition of @required="integrity" to the SCDL.

Suggestion
Each functional component consists of a series of the basic modules,
aggregated together.

1. tuscany-scdl4j
   An aggregated jar containing all the model and stax processor classes
   which can be used by tools etc for for reading/writing scdl without booting
   a runtime. It includes all the extension classes as they generally don't
   drag in any other dependencies so its not really any problem to incude include them.
   The only required dependency would be on stax, maybe some optional
   dependencies like wsdl4j as the wsdl extension may need that. Not sure if
   any of the contribution modules should be included, would have to
   investigate that a bit.
2. tuscany-runtime
   An aggregated jar containing the minimum modules to start a runtime able to
   run something like the simple calculator sample. Has dependencies on
   tuscany-scdl4j and minimal other jars - geronimo-commonj_1.1_spec, cglib,
   jaxb etc.
3. tuscany-api
   An aggregated jar containing everything tuscany/sca applications might need
   to compile - sca-api, SCADomain class from host-embedded, node2-api, jsp
   taglib etc. Has no external dependencies.
4. Single jars for all the binding and implementation type extensions which
   add the capability to the minimal tuscany-runtime. We're already starting to
   get these with the way extensions are being structured nowadays -
   binding-jsonrpc-runtime, binding-ejb-runtime, implementation-widget-runtime
   etc.

The above would make life for embedders much easier like the
Tuscany-Geronimo integration code (or JBoss when they come along) less
likely to break over releases as we add remove modules.

Next steps
Agree the complete set of functional components and the basic modules (or module) that each of them contains.

Needs further thinking
?