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 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
?

  • No labels