Platform service descriptions

[Thomas Haselwanter <thomas.haselwanter@deri.org>]

Hi,

attached is a plain text document with a first proposal for a way to 
describe our platform services, illustrated using discovery as an 
example. Angle brackets indicate sections that every platform service 
description should have.

Even this small example already nicely shows that the semantic 
description captures facts about the discoveries operations that the 
structural shells of a syntactical operation signature don't capture.

Discussion, comments welcome.

Thomas
<Service Name>
Discovery

<Informal Description of functionality>
Following the specification in the Web Service glossary, the Service Discovery component is responsible for "locating a machine-processable description of a Web service-related resource that may have been previously unknown and that meets certain functional criteria".

WSMO Discovery provides a complete conceptual solution for the discovery problem in SWS settings, defining the border line between the different steps involved in the process of locating services, namely: goal discovery, goal refinement, service discovery and service contracting. 
Assuming that the users are expressing their requests using natural language or any other means, Goal discovery is about abstracting goals from these user requests. These goals are intended to be generic and reusable, thus the second step, Goal refinement, will refine the pre-defined goal discovered in the previous step to the actual user desire. 
For the next steps, a clear distinction between services and Web services must be made: a service is a concrete instance of a Web service having all the inputs specified, while a Web service is an abstract entity, a class of concrete services. The third step becomes thus Web service discovery and implies matching formalized goals with formalized Web service descriptions, selecting Web services that can potentially be used to get the desired service. The last step becomes Service discovery and is about finding concrete services based on the abstract descriptions discovered in the previous step.

In the case of SEE, the focus is on the Web service discovery step from the WSMO framework. Three different approaches, delivering discovery results of different accuracy, have been distinguished: Keyword-based discovery, Discovery based on simple descriptions of services (also known as Lightweight semantic discovery) and Discovery based on rich semantic descriptions of services (Heavyweight semantic discovery).
In the Keyword-based discovery approach, a query engine matches the keywords from an input
query against the keywords used to describe the service. Such an approach has the advantage that a huge amount of available services can be filtered or ranked rather quickly.
In the Discovery based on simple descriptions of services, Web services and goals are modeled as sets of objects. More precisely, a Web service is represented as a set of objects that it delivers, while a goal is represented as a set of elements which are relevant to the client as the outcome of a service execution. The descriptions of these sets refer to ontologies that capture general knowledge about the problem domain under consideration. Logics based on set theory (e.g. Description Logics) are used to determine whether a goal description matches service descriptions.
In the Discovery based on rich semantic descriptions of services approach, relations between inputs and outputs of the services and the goal as well as transition states, are considered during the matching process. More expressive logics that 
provide rule support (e.g. F-Logic) can be used to determine whether a goal description matches services descriptions. 

<Informal description of interface>
The Discovery interface provides two operations by which Web services matching a specific Goal
description can be obtained. 
The first operations returns a possibly empty list of Web services that match a Goal description. 
Services are returned in descending order of how well they match
the supplied Goal. The algorithm that determines the matching is part of the implementation 
of the method itself.
The second operations allows a ranking mechanism described as an ontology to be used in the discovery
process. The ordering of results is in descending order as in the first method.
  
<Presentation of operations in pseudo syntactical syntax>
Operation A:
Searches the repository for those Web services that match the goal of the requester. 
The operation receives a goal as input and return a number of web services leading
to the following signature.
 
     discover(Goal goal): WebService[]
	

Operation B:
Searches the repository for those Web services that match the goal of the requester,
according to a specific matching function.

     discover(Goal goal, Matchtype type): WebService[]

<WSML Supportive Ontologies>
http://www.oasis-open.org/ex-semantics/ontologies/discovery
http://www.oasis-open.org/ex-semantics/ontologies/discoveryprocess
http://www.wsmo.org/2004/d2

<WSML service description>

wsmlVariant _"http://www.wsmo.org/wsml/wsml-syntax/wsml-rule";
namespace { _"http://www.oasis-open.org/ex-semantics/ontologies/discovery#";, 
      dc    _"http://purl.org/dc/elements/11#";, 
      xsd   _"http://www.w3c.org/2001/XMLSchema#";, 
      wsml  _"http://www.wsmo.org/2004/wsml#";, 
      d     _"http://www.oasis-open.org/ex-semantics/ontologies/discovery#";,
      dp    _"http://www.oasis-open.org/ex-semantics/ontologies/discoveryprocess#";,
      dc    _"http://www.oasis-open.org/ex-semantics/ontologies/discoverychoreography#";,
	  oasm  _"http://www.wsmo.org/ontologies/choreography/oasm#";,
	  d2    _"http://www.wsmo.org/2004/d2#";
}
     
webService _"http://www.oasis-open.org/ex-semantics/services/discovery";
     nonFunctionalProperties
          dc#title hasValue "Discovery"
          dc#type hasValue d2#Webservice
          wsml#version hasValue "0.01"
     endNonFunctionalProperties

     importsOntology _"http://www.oasis-open.org/ex-semantics/ontologies/discovery";

capability _"http://www.oasis-open.org/ex-semantics/services/discovery#capability";
  importsOntology { _"http://www.oasis-open.org/ex-semantics/ontologies/discovery"}

  precondition discoveryPrecondition
  postcondition discoveryPostcondition

interface DiscoveryInterface

choreography DiscoveryChoreography
    stateSignature _"http://www.oasis-open.org/ex-semantics/ontologies/discovery#statesignature";
      importsOntology {
             _"http://www.oasis-open.org/ex-semantics/ontologies/discovery";,
          	 _"http://www.oasis-open.org/ex-semantics/ontologies/discoveryprocess";,
         	 _"http://www.oasis-open.org/ex-semantics/ontologies/discoverychoreography";
      }
     
      in         d2#Goal     withGrounding { _"http://www.example.org/services/discovery/a"; }
      out        dp#DiscoveryResult
      controlled oasm#ControlState
      
transitionRules _"http://www.oasis-open.org/ex-semantics/ontologies/discovery#transitionRules";

    /*
     * Request-reply style MEP
     */	
	forall {?controlstate, ?request} with (
			?controlstate[oasm#value hasValue oasm#InitialState] memberOf oasm#ControlState and
			?request memberOf d2#Goal
		) do
			add(?controlstate[oasm#value hasValue dc#EntreatyReceived])
			delete(?controlstate[oasm#value hasValue oasm#InitialState])
			add(_# memberOf dp#DiscoveryResult)
	endForall

    /*
     * If the request specifies a match type the response will be
     * matches from this type.
     *
     * Binds to a goal even though it's not used in the conclusion
     * of the rule to make sure that we never fire without a request.
     */
	forall {?controlstate, ?request} with (
			?controlstate[oasm#value hasValue oasm#InitialState] memberOf oasm#ControlState and
			?request memberOf d2#Goal and
			?matchtype memberOf d#Match		
		) do
			add(_#[d#matchtype hasValue ?matchtype] memberOf dp#DiscoveryResult)
	endForall