The semantic web promises to bring automation to the areas of web service discovery, composition and invocation. In order to realize these benefits, rich semantic descriptions of web services must be created by the software developer. A steep learning curve and lack of tool support for developing such descriptions thus far have created significant adoption barriers for semantic web service technologies. In this paper, we present a model-driven architecture approach for specifying semantic web service through the use of a UML profile that extends class diagrams. In this paper we describe our efforts to develop a transformation approach based MDA to translate XMI specifications (e.g., XML encodings of UML) into equivalent WSMO specifications via the use of ATL transformations.
Introduction
The potential to achieve dynamic, scalable and cost-effective infrastructure for
electronic transactions in business and public administration has driven recent
research efforts towards so-called Semantic Web services, that is enriching Web
services with machine-processable semantics. As a matter of fact, describing Web
services through aforementioned submissions are not easy for service developers to
write. Although, several tools and editors such as OWL-S Editors, WSMO studio [
In order to tackle this problem, several approaches have been proposed based on
Model driven Architecture (MDA) [
In this context, we are developing an approach that allows a developer to focus on
creation of semantic web services and associated WSMO [
The remainder of this paper is organized as follows. Section 2 describes the related works for semantic web services approaches, a WSMO overview is presented in section 3. The specifics of our approach, details and the main parts of our solution are presented in Section 4. Sections 5 and 6 discuss implementation and conclusions, respectively. 2
In this section we present briefly various approaches which allow to use UML for
the creation of ontologies. Gasevic [
Brambila et al in [
MIDAS-S [
The WSMO initiative aims at providing an overarching framework for handling Semantic Web services (SWSs). WSMO identifies four main top-level elements: 1. Ontologies that provide the terminology used by other elements; 2. Goals that state the intentions that should be solved by Web Services; 3. Web Services descriptions which describe various aspects of a service; 4. Mediators: to resolve interoperability problems.
Each of these WSMO Top Level Elements can be described with non-functional
properties like creator, creation date, format, language, owner, rights, source, type;
etc. WSMO comprises the WSMO conceptual model, as an upper level ontology for
SWS, the WSML[
The Web Service Modeling Language (WSML) is a formalization of the WSMO ontology, providing a language within which the properties of Semantic Web Services can be described.
WSMX provides an architecture including discovery, mediation, selection, and invocation and has been designed including all required supporting components enabling an exchange of messages between requesters and the providers of services. 4
The approach relies upon the use of MDA concepts by developing two metamodels (source and target one) and a transformation model to translate XMI specifications (e.g., XML encodings of UML) into WSMO.
Figure 1 shows the overview of our approach. The model transformation is based on ATL language, and its relates two metamodels (source:UML and target: WSMO). A transformation engine takes a source model as input, and it executes the transformation program to transform this source model into the target model. The business model is created by any UML tool, consistent with the UML metamodel (UML profile). The obtained WSML document will be exported and validated by WSMO studio Tool.
UML Tool MDA
C2 UML
C2 Model.uml
EMF Model Transformation (ATL)
C2 : Conforms To
C2 WSMO
C2 Model.wsml
A UML profile [
NonFunctionalProperties axiom
NameSpace Standard UML
Generalization ooMediator subConceptOf subRelationOf
Standard UML 2.0
Class
Standard UML 2.0
Dependency Concept axiom
Relation
importsOntology Standard UML 2.0
Comment
Standard UML 2.0
Usage useMediator
Transitive Instance
Standard UML 2.0
InstanceSpecification Standard UML 2.0
Association symmetric
InverseOf impliesType reflexive
Standard UML 2.0 +Package +Comment +Class +Dependency +Usage +Generalization +Attribute +Association +InstanceSpecification Standard UML 2.0
Package Ontology
Standard UML 2.0 Attribute OfType
impliesType • The standard elements of UML: which are represented in the figure 2 by yellow color, we used: package, comment, Class, Dependency, Usage, Generalization, Attribute, Association, and InstanceSpecification. All these elements can be used in the class diagram for modeling the business model. • Stereotypes: represented in the figure by the green color, they are introduced to allow the modeling of the diverse WSMO’s constructs. The WSMO’s constructs that we used are: "Concept", " axiom ", "relation" which extend the " Class " element. "Ontology", "ooMediator " which extend the "Package" element. "NonFunctionalProperties","axiom" and "NameSpace" which extend the "comment" element. " ImportsOntology " which extends the " Dependency " element. "Instance" which extends the " InstanceSpecification " element. « subConceptOf» and « subRelationOf » which extend « Generalization » element.
« OfType » and « impliesType » which extend « Attribute » element. « symmetric », « InverseOf », « impliesType », « reflexive » and tive » which extend « Association » element. « Transi4.2
This metamodel [
The figure 3 shows a fragment of WSMO metamodel.
The overview of the transformation is detailed in Figure 4. The set is split between two areas of modeling: MDE for space engineering models in which is defined the different metamodels described above and the transformation between UML and WSMO, and WSMO space that defines the WSMO ontologies. In M3 layer we find ECORE language of metamodelisation. The both metamodels (UML and WSMO) and ATL metamodel located in M2 layer are based on ECORE.
At M1 layer we found the source model expressed in UML 2.0 conforms to our metamodel WSMO UML Profile, the model transformation UML2WSMO implemented in ATL language, WSMO ontology model resulting from the transformation process which is conforms to WSMO target metamodel in M2 layer, and a WSMO / WSML projector. This projector is a particular transformation that allows to switch from one model space to another. In our case it is used to transform the WSMO ontology in WSML document. Now we will explain in detail the transformation rules between our UML profile and WSMO ontology.
UML M3
M2 MODEL Legend : ConformsTo
Ecore
ATL UML2WSMO
MDE WSMO MODEL : Projector : transformation
WSMO/WSML
Projector
WSMO
WSML WSMO
Ontology
Space modeling
In our approach, a transformation definition is implemented in ATL language based on a mapping specification; we use the term mapping as a synonym for correspondance between the elements of two metamodels, while a transformation is the activity of transforming a source model into a target model in conformity with the transformation definition.
The source metamodel UML profile includes stereotypes, tagged values and constraints, each of which map to a particular construct in target metamodel WSMO description, as shown in table1. The left hand column provides the abstract type represented by the constructs. The middle column shows the UML constructs used to specify semantic services. Finally, the right hand two colomns name the corresponding target construct in WSMO specification and present the target elements which are defined in this transformation.
Once mappings are specified between the two metamodels (e.g. UML and WSMO), transformation definitions are implemented using transformation languages such as Atlas Transformation Language (ATL). An extract of these rules is illustrated below. • Rule : UMLClass2WSMOConcept
This rule allows to create a concept WSMO from a class UML stereotyped "Concept". Any class UML stereotyped "Concept" is transformed into WSMO concept. This one is defined by the concepts from which it inherits “subConceptOf” , by a Name, NonFunctionalProperties and by these attributes.
rule UMLClass2WSMOconcept { from s : UML!"uml::Class" (s.hasStereotype('WSMO_Profil::Concept')) to t : b_Ontology_WSMO!Concept (
Nom_concept <- s.name->debug('Cette Class Est Un Concept '), SubConceptOf <- if s.general.oclIsUndefined()then ''
else s.general->collect(a|a.name).first() endif,
NonFunctionalProperties<b_Ontology_WSMO!NonFunctionalProperties.allInstances() ->select(b|b.Nom_De = s.name)>collect(b1|b1.Corps).first(),
Attribute <- b_Ontologie_WSMO!Attribute.allInstances() ->
select(b|b.Nom_De_Class = s.name)->collect(b1|b1.Nom_Attribute) ) }
The helper " hasStereotype " receives a string and returns a boolean. It is used to know if the current UML element is stereotyped as the string taken in parameter. helper context UML!"uml::Element" def: hasStereotype(name : String) : Boolean = self.getAppliedStereotype(name)->oclIsKindOf(UML!Stereotype); • Rule : Property2Attribute
This rule allows to create attributes WSMO from UML properties stereotyped " OfType ". Any property UML stereotyped "OfType" is transformed into WSMO attribute. This one is defined by a Name, Type, class names and Attribute name. rule Property2Attribut { from P : UML!Property ( P.hasStereotype('WSMO_Profil::ofType')) to A : b_Ontology_WSMO!Attribute (
Nom_Attribute <- P.name + ' ofType' + ' ' + P.type.toString().substring(4,P.type.toString().size()), Type_Attribute <- P.type.toString().substring(4,P.type.toString().size()), Nom_De_Class <- P.class.name ), At : b_Ontologie_WSMO!AttRelation ( Nom_Attribute <- ' ofType ' +P.type.toString().substring(4,P.type.toString().size()), --Type_Attribute <- P.type,
Nom_De_Class <- P.class.name ) } • Rule : InstanceSpecification2WSMOInstance
This rule transforms UML instance into WSMO instance. This one is defined by the classes that are “ MemberOf”, InstanceName and AttributeValues. rule UMLInstance2WSMOInstance { from I : UML!InstanceSpecification to Ins : b_Ontology_WSMO!Instance ( Nom_Instance <- I.name,
MemberOf <- I.classifier->collect(a|a.name), AttributeValues <- b_Ontology_WSMO!AttributeValue.allInstances( ) ->select(b|b.name = I.name)->collect(a|a.Nom_Att_Ins) ) }
A projector consists of one or several transformations allowing realizing the projection of an artefact belonging to a technological space towards another. In our case, the artefact is a model in compliance with the WSMO metamodel, belonging to the technical space of MDE. We aim to project this artefact towards the WSMO space in WSML syntax. A model in the MDE space is serialized in the XMI format, whereas a document in the WSMO space is in WSML format. The projector implemented here includes a single ATL query file allowing the transformation of WSMO model into a WSML document. Among the main rules which compose the transformation file named Ecore2wsmo, we quote the first rule: •
Rule 1 : This rule allows to translate the "concept" element of WSMO modeled in ECORE Format into WSML syntax. helper context UML!Concept def : toString_b() : String =
'\n'+' concept ' + self.Nom_concept + if self.SubConceptOf->iterate(e; acc : String = '' |acc + e.toString()+ '') = 'OclUndefined' then '\n' else ' subConceptOf '+self.SubConceptOf->iterate(e; acc : String =' ' |acc + e.toString() +' ') + '\n' endif + if self.NonFunctionalProperties.oclIsUndefined() then ''
else ' nonFunctionalProperties '+ '\n' + self.NonFunctionalProperties + ' endNonFunctionalProperties ' + '\n' endif + if self.Attribute.size() <> 0 then self.Attribute->iterate(e; acc : String = '' |acc + e.toString() + '\n') + '\n' else '' endif; 5
To show the feasibility of our approach, we have developed a tool on the Eclipse environment (Eclipse Ganymade 3.4.2), an ATL project is created, the UML metamodel profile is modeled by UML diagrams 2.1 Integrated in EMF eclipse, and the WSMO metamodel is modeled by the Ecore language (Ecore diagram), then two ATL files containing the transformation rules (UML2WSMO and WSMO2WSML) are written in ATL. For each execution, we introduce a source model conforms to our source metamodel and we obtain a WSMO document.
To illustrate our approach, we take the human ontology as an example, the source
model is expressed in a UML2.0 class diagram in conformity with our source
metamodel (see Fig.5). The transformation engine takes the source model serialized in
XMI [
Semantic Web Services can potentially change the way software is both developed and used. In order to realize that great promise, the software development community must embrace the technology. The barriers to adoption must be bridged in a manner that leverages the capabilities of developers.
We have been developing an MDA-based approach for facilitating such adoption by using Metamodels at PIM levels in such way that it more adequately hides the details of semantic web service technologies and allows the developer to focus on creating models of semantics web services, Then a transformation model consisting of a defined set of rules that specify the correspondence between the elements of both source and target metamodels, is applied to generate a WSMO ontology encoded in WSML.
Our current investigations involve developing the framework in such a way that it improves the transformation model by handling the logical expressions to cover "axiom" and covers the other parts of WSMO like capability, mediators and goals. 7