 This page is under constructionwill move to the website when it is complete. Please help to complete it. Thanks.
What this is aboutThis page can be used by those who would like to pick and choose pieces of Tuscany and embed it with their software or create smaller distributions to use. It outlines dependencies and identifies the minimum set of modules required to use Tuscany. Current Tuscany Packaging StateAs of release 1.3 Tuscany binaries are SCA is distributed via one binary distribution that includes everything. Based on user feedback, choice of a smaller distribution packages is desireable. Tuscany community is in the process of addressing this requirement. Please see discussions on the mailing list and contribute if interested. How to build your own distributionLet's use the term "feature" to refer to a package. This is also used in Eclipse and many people are familiar with it. A Tuscany user has defined a set of features applicable to his application at this location. Althought these features address this user's requirements, there might be variations of packaging that other users may need(we would like to hear your opinion). We realize that there will always be a need for smaller features or a combination of features. For that reason, this page is created to help you understand dependencies and be able to create your own distribution if needed. For the sake of this conversation, let's assume that the minimum bar is a distribution that allows you to do the following
1. Build SCA applications
2. Access external services through webservice
3. Use web20 Let's use the existing features in the source tree as a starting point to see if the modules bundled are sufficient to define the dependency of modules required to do the above 3 taskes. - core feature - pom.xml
This package includes support for building applications based on Java components and also exposes SPIs for extending Tuscany SCA to include extensions such as binding types, implementation types, policies.
This could be the minimum required to use Tuscany. - Included in this feature:
1. Core runtime includes OSGI support
2. Launchers
2a) j2Se
2b) equinox
2c) Webapp
3. Bindings:
2a) SCA default binding
2b) corba (as a light weight binding that you can use with the core distro
4. Data Bindings: Jaxb
5. Interfaces
4a) Java
4b) Wsdl
Is this sufficient?
- webservice feature - pom.xml
This package provides support for webservices binding based on Axis2. - Included in this feature:
1. Core Runtime: Core feature
2. support for webservices
In addition to what is included in core feature:
3. Bindings; ws, ws-axi2, ws-wsdlgen, ws-xml
4. Databindings: Jaxb-axiom, SDO, SDO-axiom
Is this sufficient?
- web20 feature - pom.xml
This package enables you to use web20 with Tuscany. - Included in this feature:
1. Core Runtime: Core feature
2. Support for resources and widgets
In addition to what is included in core feature:
3. Bindings; Atom (via Abdrea), Jason, RSS (via Rome), HTTP,
4. Databindings: JSON
Is this sufficient? How to build my own distribution?(I am really struggling with how to identify dependencies the easiest way so that we don't have to keep a static table) Understanding dependenciesTo understand module dependencies, you can start with a particular feature and run one of the following commands. | Code Block |
|---|
go to the feature directory and issue the command:
mvn:site
This will create a file called dependencies.html that shows dependencies amongst modules that create this feature.
|
or for the text version of the dependencies you can use the following command | Code Block |
|---|
mvn dependency:tree for that discussion. This is not the purpose of this page. Tuscany users have asked for a write-up that highlights module dependencies. This enables them to build their own distribution which may have a lower or higher granularity than the pre-packaged binary distributions. Purpose of this page is to help users understand how to build their own tuscany SCA light distribution based on module dependency knowledge that is shared here. Therefore:
This page is not about building Tuscany building binary distributions to distribute
This page is about understanding dependencies so that users can build their own distribution How to build your own distributionLet's first understand the different categories of module types in Tuscany. This understanding will help us determine how to put the modules together to have a runnable and useful system. - Core type modules- These are modules that enable you to use SCA programming model to create applications
- Binding type modules - Bindings handle protocols between two services. Tuscany supports many bindings. One or more modules constitute a binding.
- Component type modules - These are the modules that enable you to use different languages or container models to create SCA components. Tuscany supports different component types. There are a set of modules that support each component type. For example, java, BPEL, Spring, etc. There are specific modules that support a given component type.
- Policies type modules- There are different policy types. For example security, monitoriing, etc. There are specific modules that support each policy.
- Databinding type modules - These modules support data types. Tuscany supports many data bindings, including Jaxb, SDO, Axiom, Json/rpc. There are specific modules that support a given data binding.
- Runtime Type modules- Tuscany supports different runtimes. There are specific modules that support a given runtime.
Now that you understand the different module types, let's identify the module that fall into each category. Understanding dependencies<Insert dependencies>
(Struggling with how best to demonstrate this) Minimum rquired to build and run SCA applicationsExamples for including bindingsExamples for including Web20 | 