Servus* is a proposed open source component under the Eclipse Modeling Framework Technologies (EMFT) project. The component’s purpose is to promote EMF to a central role in the design and evolution of Web Services, mainly by creating mappings from Ecore based models to Web Services Description Language (WSDL) and code artifacts.
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process document) and is written to declare its intent and scope. This proposal is written to solicit additional participation and input from the Eclipse community. You are invited to comment on and/or join the component. Please send all feedback to the eclipse.technology.emft newsgroup.
The <a href="http://www.eclipse.org/modeling/emf/">Eclipse Modeling Framework</a> (EMF) represents a pragmatic approach to model-driven development that focuses on incremental adoption, highly customizable code generation, implementation of common standards and development of infrastructure to work with models in the form of frameworks and tools. Recent years have also seen the emergence of Web Services technologies that allow to publish, discover and invoke services in a platform independent fashion over the internet, and the Service Oriented Architecture (SOA) as a means to modularize functionality as services and build ad-hoc applications from existing services.
Many Java-based projects support Web Services in different ways. WS engines, such as <a href="http://ws.apache.org/axis2/">Apache Axis2</a> and <a href="http://incubator.apache.org/cxf/">CXF</a>, provide minimal code generation and thus some WSDL⇔Java mapping, but with little or no support for customizations and incremental generation. The <a href="http://www.eclipse.org/webtools/">Eclipse Web Tools Platform</a> (WTP) project provides a WSDL editor, but the manipulation occurs in terms of WSDL concepts, without raising the abstraction level. Still, developers are constantly having to deal with the complexity of a multitude of standards that constitute the Web Services stack (WSDL, SOAP, JAX-WS, JAX-B, etc), facing platform interoperability problems and dealing ad-hoc with evolution.
The purpose of this component is to take advantage of EMF capabilities to address limitations of development using current Web Services technologies, creating a bridge between Model-driven and Web Services technologies and promoting EMF to a central role in the task of designing and evolving Web Services.
The main focus of the Servus component is to allow developers to design and evolve Web Services (WS) using Ecore based models, by providing mappings between those models and Web Services artifacts, such as WSDL descriptions, WS client stubs and WS server skeletons. In the following we describe the component’s scope in the form of a set of artifacts, depict the value added by these artifacts and sketch an initial roadmap for the implementation. The scope is an initial attempt and may be incremented as we receive feedback from the community.
The following list of artifacts constitutes the component’s scope:
- An implementation of an EMF-based WSDL Data Binding.
- A mapping Ecore⇔WSDL for each WSDL version (currently 1.1 and 2.0).
- Mappings Ecore⇔Client Stubs, i.e., Java code implementing Web Service clients.
- Mappings Ecore⇔Server Skeletons, i.e., Java code implementing Web Service servers.
- Support for refactoring the Ecore model and reflect changes in other artifacts.
The Servus component must have a modular architecture, so that it is possible to implement mappings to different Web Service engines and frontends in addition to the default ones (as specified in the Roadmap). The following items are NOT in the scope of the project:
- Mappings to a complete Web Services stack - we concentrate on the mappings to the “frontend” (client stubs and server skeletons), WSDL and WSDL data bindings.
- A full fledged refactoring engine - while Servus could take advantage of such an engine, it is not the scope to produce one, as it would be a project in its own.
The mentioned artifacts will promote Ecore models as pivotal in the design and evolution of Web Services. We see the following primary advantages:
- By having an EMF-based WSDL Data Binding, developers can reuse their application’s data model implemented as an Ecore model across Web Services.
- By mapping the Ecore model to different versions of WSDL we can support evolution between WSDL versions. For example, we reverse engineer a WSDL 1.1 version of a service and generate a similar WSDL 2.0 version.
- By having the Ecore model as the pivotal model developers concentrate on “what the services do“, while ”how it is done“, i.e., implementation details, get hidden (including details of the several standards in use).
- By using EMF’s code generation capabilities it is possible to support incremental generation and customization of generated artifacts.
- By having mappings to different artifacts, such as WSDL, client stubs and server skeletons, we assist developers in many scenarios, like creating an application that uses an existing published service (WSDL⇒Ecore⇒Client Stubs), creating a new service and publishing it, integrating different services, and so on.
- By creating refactoring support in the model level, EMF-Servus aids Web Service evolution, for example, by regenerating artifacts based on a different service interface.
The roadmap for the implementation is composed of 5 initial ”loosely defined“ development stages. The project’s goals are very ambitious in some aspects, such as incremental compilation and evolution support. Therefore, the goal of this roadmap is to bring as much simplified functionality as soon as possible, so that we gather a community around the project and prepare the infrastructure for the most challenging tasks.
- EMF CXF DataBinding
We propose using Apache CXF Web Services engine as the initial target engine, because it aims at standardization and provides an extensible API. This stage will create a DataBinding extension to the CXF engine that uses EMF.
- WSDL 1.1⇔Ecore
- Ecore⇒CXF (JAX-WS) Client Stubs
- Ecore⇒CXF (JAX-WS) Server Skeleton
We propose the use of JAX-WS as the main target frontend. JAX-WS defines standard ways of developing client and server portions of Web Services and is supported by CXF. This stage will create a full mapping between WSDL 1.1 and Ecore models, and allow the generation of Client Stubs and Server Skeletons from the model. Artifacts generation will initially focus on using Eclipse’s <a href="http://www.eclipse.org/modeling/m2t/">Model2Text Project</a> engines.
- WSDL 2.0⇔Ecore
- Ecore⇐CXF (JAX-WS) Client Stubs
- Ecore⇐CXF (JAX-WS) Server Skeleton
- Support for refactoring
- <a href="http://swen.uwaterloo.ca/~ttonelli">Thiago Tonelli Bartolomei</a>, Project Lead and Commiter
- Ph.D Candidate with the <a href="http://gsd.uwaterloo.ca">Generative Software Development Lab</a>, <a href="http://www.uwaterloo.ca">University of Waterloo</a>, Canada, and <a href="https://www-927.ibm.com/ibm/cas/index.shtml">IBM CAS</a> Ph.D Fellow with <a href="https://www-927.ibm.com/ibm/cas/toronto/index.shtml">Toronto Labs</a>.
* "<a href="http://en.wikipedia.org/wiki/Servus">Servus</a>" is a greeting commonly used around the regions
of the former Austro-Hungarian Empire meaning "I am your servant" or "At your service".