Generating and Instantiating Abstract Workﬂows with QoS User

Requirements

Claudia Di Napoli

, Luca Sabatucci

, Massimo Cossentino

and Silvia Rossi

C.N.R., Istituto di Calcolo e Reti ad Alte Prestazioni, Napoli, Italy

C.N.R., Istituto di Calcolo e Reti ad Alte Prestazioni, Palermo, Italy

DIETI, Universit

a degli Studi di Napoli Federico II, Napoli, Italy

Keywords:

Service-oriented Computing, Automatic Service Composition, Multi-agent Negotiation.

Abstract:

The growing availability of services accessible through the network makes it possible to build complex ap-

plications resulting from their composition that are usually characterized also by non-functional properties,

known as Quality of Service (QoS). To exploit the full potential of service technology, automatic QoS-based

composition of services is crucial. In this work a framework for automatic service composition is presented

that relies on planning and service negotiation techniques for addressing both functional and non-functional

requirements. The proposed approach allows for dynamic service composition and QoS attributes, and it can

be applied when services are provided in the contest of a competitive market of service providers without

knowledge disclosure.

1 INTRODUCTION

Service-oriented computing (Papazoglou et al., 2007)

is opening new frontiers in the development of added

value applications, known as Service-Based Applica-

tions (SBAs), resulting from the combination of dif-

ferent services provided by different providers at dif-

ferent conditions, so leading to the vision of an open

market of services regulated by demand and supply

mechanisms.

In this context, the value of commercial Service-

Based Applications (SBAs) depends not only on the

functionality they deliver, but also on the value of

their non-functional properties, known as Quality of

Service (QoS), that are not tied to the speciﬁc func-

tionality, but rather to “how” it is provided, i.e. how

well a service serves the customer (Strunk, 2010), in

terms of its non-functional aspects (e.g. performance,

reliability, availability, cost). In fact, service imple-

mentations having similar functional capabilities are

distinguishable for their QoS values that determine

whether a service is reliable, trustworthy, or efﬁcient,

since it may be functionally capable of performing

a given task, but it might not be reliable or efﬁcient

enough in performing the task up to the user satisfac-

tion (Shehu et al., 2014).

When dealing with applications composed of ser-

vices orchestrated according to a speciﬁed workﬂow,

QoS values are usually speciﬁed at the application

level, rather than at level of the single components,

and they result from the aggregation of the QoS val-

ues of each component service, according to a func-

tion depending on the nature of the considered QoS

parameters, and on the structure of the SBA workﬂow

These end-to-end QoS values depend on the values

of each component service, aggregated according to a

function usually depending on the nature of the con-

sidered QoS parameters, and on the structure of the

SBA workﬂow.

In order to automatically compose QoS-aware

SBAs in response to a user request with QoS con-

straints, several approaches have been proposed in the

literature (Moghaddam and Davis, 2014). Static ap-

proaches typically assume that QoS parameters are

pre-deﬁned for each service, and they do not change

during the composition process. These approaches

are not suitable within the vision of a dynamic mar-

ket of services, since QoS values may vary accord-

ing to the provision strategies of providers as well as

to users’ requirements expressed as global constraints

on the SBA’s QoS. So, heuristic approaches leading

to sub-optimal solutions are often adopted where ser-

vice QoS values are not known prior to generating the

workﬂow, reﬂecting a more realistic scenario.

In the present work, we present an integrated

framework that allows performing all stages of an

276

Di Napoli C., Sabatucci L., Cossentino M. and Rossi S.

Generating and Instantiating Abstract Workﬂows with QoS User Requirements.

DOI: 10.5220/0006203902760283

In Proceedings of the 9th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2017), pages 276-283

ISBN: 978-989-758-219-6

automatic QoS-based service composition process,

ranging from ﬁnding functionally equivalent compo-

sitions, to the selection of an appropriate composi-

tion that meets the non-functional user’s constraints.

The framework allows to deal with cases in which i)

there could be more plans (i.e. combinations of ser-

vices providing a complex service) to satisfy the same

set of user requirements, and ii) there could be more

providers for the same service in a plan. In fact, a

complex service can be realized by different plans,

and each plan may be composed of a high number

of tasks. In a real scenario, each task may be possi-

bly accomplished by different services providing the

same functionality. When there is a high number of

possible service combinations providing the complex

task, the problem of selecting an optimal combination

that meets the QoS values speciﬁed by a request be-

comes intractable. The framework provides an auto-

matic reasoner, and it is equipped with automated ne-

gotiation capabilities. The reasoner produces several

workﬂows of services (or plans) by aggregating dif-

ferent combinations of capabilities. Each workﬂow

represents an alternative solution for addressing the

speciﬁed functional part of a user request. The au-

tomated negotiation –upon QoS attributes values of

single services– allows to select services whose QoS

values, once aggregated, meet the QoS constraints set

by the user.

The paper is organized as follows: Section 2 re-

ports some related work on QoS based service selec-

tion in service composition. Section 3 focuses on the

integration of the approach for service composition

with the strategy for service selection. An example

of a QoS based complex service composition in the

domain of Travel Service is presented in Section 4.

Finally, some conclusions are drawn in Section 5.

2 QoS BASED SERVICE

SELECTION

In QoS-aware service composition, the selection of

service implementations is based on the QoS values

of the candidate services. When the QoS values are

expressed at the level of the complete application, the

problem of ﬁnding a combination of services whose

QoS values, once aggregated, meet the QoS require-

ments is a constrained optimization problem that can

be reduced to the Multi-Choice Knapsack problem

known to be NP-hard. Several approaches propose

algorithms to optimize the global QoS values of a ser-

vice composition subject to multiple QoS constraints

(Zeng et al., 2004), (Ardagna and Pernici, 2007), (Yu

et al., 2007), (Alrifai and Risse, 2009). These ap-

proaches rely on prior knowledge of the component

service QoS values. They do not consider dynamic

changes in QoS, so they are not suitable in an open

market of services where QoS values may constantly

change over time, as it is assumed in the present work.

Heuristics approaches have been investigated to

ﬁnd near-optimal combinations in dynamic environ-

ments. In this research line, negotiation mechanisms

were shown to be a suitable approach to deal with

QoS-aware SBAs (Yan et al., 2007), (Di Napoli et al.,

2014), (Lau, 2007).

Negotiation solutions are divided by the assump-

tion that the service providers are or not predeter-

mined before negotiation. The two approaches are

known as pre-contractual negotiation, and dynamic

provider selection. Pre-contractual negotiation usu-

ally applies negotiation for each required service in-

dependently from the others, relying on bilateral one-

to-one negotiation mechanisms such as in (Yan et al.,

2007), (Paurobally et al., 2007), (Siala and Ghedira,

2011), not allowing competition among providers.

In other approaches negotiation occurs after an opti-

mization phase, but only among the providers that do

not provide the expected QoS local values (Ardagna

and Pernici, 2007). The approach in (Di Napoli et al.,

2014) proposes a coordinated negotiation mechanism

with all providers of the different services in the com-

position, taking into account their contribution to the

global QoS values. The negotiation occurs concur-

rently with all service providers, and it requires a co-

ordination point to synchronize the concurrent nego-

tiations for global evaluation. This approach allows to

exploit the competition among service providers with-

out excluding less promising providers that could be-

come more competitive while negotiation proceeds.

3 AUTOMATIC QoS-AWARE

SERVICE COMPOSITION

The framework proposed for automatic composi-

tion of services with speciﬁed QoS user’s prefer-

ences allows to address both functional and non-

functional users requirements by integrating MUSA,

a middleware for service composition and orches-

tration (Sabatucci and Cossentino, 2015; Sabatucci

et al., 2016), with a QoS based service negotiation

module (Di Napoli et al., 2014), hereafter QoS Nego-

tiation.

The overall process for QoS-aware service com-

position is split in ﬁve phases:

1. the formulation of a user’s goal specifying a re-

quired functionality, together with non-functional

requirements expressed in terms of QoS values,

Generating and Instantiating Abstract Workﬂows with QoS User Requirements

277

2. automatic composition of abstract plans to ad-

dress the goal via AI planning techniques,

3. service discovery, i.e. the identiﬁcation of con-

crete services matching the functional require-

ments of the tasks that compose the abstract plan,

4. QoS service selection, i.e. the identiﬁcation of

one concrete service implementation for each task

of the plan whose QoS values, once aggregated

with the values provided by the other services in

the composition, satisfy the user’s preferences,

5. service binding, i.e. instantiation of the abstract

plan into an executable workﬂow, ready to be en-

acted.

Steps 1 and 2 are conducted by MUSA, whereas

the QoS Negotiation enacts steps 3, 4 and 5.

3.1 MUSA

MUSA (Middleware for User-driven Service Adapta-

tion) (Sabatucci et al., 2016; Sabatucci et al., 2015)

is a middlware for composing and orchestrating dis-

tributed services according to unanticipated and dy-

namic user needs. It is a platform in which 1) virtual

enterprises can deploy capabilities that wrap real ser-

vices, completing them with a semantic layer for their

automatic composition; 2) analysts and/or users can

inject their goals for requesting a speciﬁc outcome.

Under the hypothesis that both goals and capabilities

refer to the same ontology, agents of the system are

able of composing available services into plans for

addressing the user request.

The main abstraction in MUSA is a capability,

which represents something that the system knows

how to do, and goals, used to represent the user’s

requirements. In MUSA, a user is able to describe

a desired functionality via a high-level goal-oriented

description language, called GoalSPEC (Sabatucci

et al., 2013). At run-time, once a goal model is spec-

iﬁed (often it is a tree hierarchy of goals), it may be

injected in the system. This event triggers the forma-

tion of an agent group that is committed to address

the goal (and all its subgoals). Goals represent condi-

tions, in terms of states of the world, a user may want

to be addressed.

A proactive means-end reasoning (Sabatucci and

Cossentino, 2015) associates system capabilities to

user goals for deducing possible service compositions

that can guarantee the desired ﬁnal state. This proce-

dure works on two main abstractions: the Abstract

Capability and the Goal.

MUSA also provides a capability language, based

on predicate logic, that allows to specify additional

information about a service (Sabatucci et al., 2016;

Sabatucci et al., 2015). The description of a service

is made of two parts: an abstract part and a concrete

part. The Abstract Capability represents a generaliza-

tion of a service, and it forces the idea of categories

of services that produce similar results but that are

offered by different providers. It offers a descriptor

for the common elements of a category of similar ser-

vices: pre and post conditions, to be checked before

and after service execution, and evolution, to be used

in order to simulate the effects of the service for en-

abling the automatic composition.

The Conﬁgurator group is an emerging organiza-

tion of agents whose responsibility is to aggregate

capabilities in order to address a given goal through

a procedure called Proactive Means-End Reason-

ing (Sabatucci and Cossentino, 2015). This procedure

works on two main abstractions: the Abstract Capa-

bility and the Goal. Goals represent conditions, in

terms of states of the world a user may want to be

addressed.

When more Concrete Capabilities are available

for the same Abstract Capability, multiple Concrete

Workﬂows could be obtained, so a selection among

them has to be made. To date, MUSA does not pre-

scribe a speciﬁc strategy for service selection among

concrete services that may provide different QoS.

3.2 QoS Negotiation

In the approach proposed in (Di Napoli et al., 2014),

negotiation is used as a dynamic service selection

mechanism, aiming at selecting the services that best

match the service requester’s non-functional require-

ments, allowing to manage the dynamic nature of QoS

values. In fact, as pointed out, while a service func-

tionality is static, and it is a characterizing intrinsic

feature of the service itself, its non-functional features

may vary, as well as users’ QoS requirements/prefer-

ences. This is even truer when services are provided

in an open market of services, as it happens already

for several classes of services in different application

domains where services are considered digital goods

to be purchased.

The negotiation occurs between the service re-

quester, represented by a software agent, we refer to

as the Service Negotiator (SN), and the candidate ser-

vice providers, represented by software agents, we re-

fer to as the Service Providers (SPs). They negoti-

ate upon the QoS values of the single services whose

functionalities are required in the composition, reach-

ing an agreement if the local QoS values of each ser-

vice, once aggregated, meet the global QoS require-

ments speciﬁed by the user when the goal speciﬁ-

cation is injected in the system. So, a successful

ICAART 2017 - 9th International Conference on Agents and Artiﬁcial Intelligence

278

negotiation selects the composition of services that

best matches the service requester’s non-functional

requirements.

The adopted negotiation mechanism is based on

an iterative protocol, where the negotiator is the ini-

tiator acting on behalf of the service requester, and

the providers formulate offers specifying the QoS val-

ues of the service they are able to provide (Di Napoli

et al., 2014). The Service Negotiator evaluates the

received offers, without issuing counteroffers, since,

as it happens in a real market of services, it is un-

likely to have enough information on the providers’

strategies to formulate counteroffers. In addition, in a

service composition, counteroffers for a single func-

tionality cannot be formulated independently from the

ones received for the other functionalities. In other

words, negotiating over the attributes of the single

abstract services cannot be done independently from

each other. Single counteroffers could be formulated

only if negotiation occurs on one service after another,

since in a composition of services changing the QoS

values of one service can be done only assuming that

the QoS values of the other services are ﬁxed. This

approach would result in serializing the negotiation,

so leading to a long process depending on the num-

ber of abstract services in a workﬂow, not suitable in

a dynamic market of services (Di Napoli et al., 2015).

The negotiation mechanism allows the negotiator

to negotiate with all providers of services with the

same required functionality required in the abstract

workﬂow, and to evaluate if the aggregated QoS val-

ues of the received offers meet the user QoS require-

ment, so to decide whether or not to accept the offers.

The negotiation protocol is organized in a set

number of negotiation rounds, until a deadline is

reached, or the negotiation is successful. The deadline

is the number of allowed rounds. Within a round, the

negotiator concurrently negotiates with all available

providers both with the ones having the same func-

tionality, and with the ones having different function-

alities. The end of a negotiation round represents a

synchronization point allowing the negotiator to eval-

uate the global QoS values, that is a necessary coor-

dination step to negotiate for end-to-end QoS values.

The negotiation process starts when an Abstract

Workﬂow (AW) is produced. It is a directed acyclic

graph AW = (AS, P) where AS = AS

, . . . AS

is a set

of nodes, and P is a set of directed arcs. Each node

represents an Abstract Service (AS), i.e. a generic

service description that speciﬁes a required function-

ality in the composition of services. The Service

Negotiator prepares m call for proposals (cfps), one

for each Abstract Service in the Abstract Workﬂow

(AW), each one sent to the set of n available providers

for that Abstract Service. So, at each round m ∗ n cfps

are sent. After waiting for the time set to receive of-

fers (i.e., the expiration time of a negotiation round),

the negotiator checks if there are offers for each Ab-

stract Service; if not, it declares a failure since it is

not possible to ﬁnd a Concrete Service corresponding

to each Abstract Service. Otherwise, it evaluates a se-

lected set of offers, one for each Abstract Service, and

according to the result of the evaluation, it performs

one of the following actions:

• if the aggregated QoS values of the selected of-

fers do not meet the user QoS request, it asks for

new offers by sending again m∗n cfps, so starting

another negotiation round with all the providers;

• if the aggregated QoS values of the selected of-

fers meet the user QoS request, it accepts the of-

fers sent by the corresponding providers (one for

each abstract service), so ending the negotiation

successfully;

• if the deadline is reached without a success, the

negotiator declares a failure to all providers that

took part in the negotiation.

In order to check if there is a combination of of-

fers that satisﬁes the end-to-end QoS constraint, at

the end of a negotiation round t the Service Negotia-

tor selects the most promising offer for each Abstract

Service, and then it veriﬁes if the aggregation of the

selected offers meet the user’s constraints, to avoid

the computation of all possible combinations of of-

fers received for each Abstract Service. In the case of

additive QoS parameters, and QoS user requirements

representing an upper bound for acceptable composi-

tions, a promising offer ¯x

i, j

at round t for AS

is com-

puted according to the approach proposed in (Alrifai

and Risse, 2009), as follows:

¯x

i, j

= argmax

i, j

∈AS

(

max(x

i, j

) − x

i, j

∑

k=1

max(x

k, j

) −

∑

k=1

min(x

k, j

)

) (1)

where m is the number of Abstract Services compos-

ing the Abstract Workﬂow, max(x

i, j

) is the maximum

i, j

value offered by the service provider j for the QoS

parameter among all the available offers for the AS

at time t, while min(x

i, j

) is the corresponding mini-

mum x

i, j

attribute value. Equation 1 estimates how

promising an offer is w.r.t. the other offers for the

same Abstract Service (local evaluation), and to the

entire workﬂow (global evaluation) by providing an

indication of how good the value of each QoS param-

eter is w.r.t the QoS values offered by other providers

of the same Abstract Service (the numerator), in re-

lation to the possible aggregated values of the same

Generating and Instantiating Abstract Workﬂows with QoS User Requirements

279

Abstract

Capability

Concrete

Capability

implements

Concrete

Workﬂow

Abstract

Workﬂow

<<agent>>

Conﬁgurator

generates

Functional

Requirements

satisﬁes

<<agent>>

Service

Orchestrator

enacts

composes

addresses

QoS

Requirements

satisﬁes

User

Speciﬁcations

<<agent>>

Service

Provider

provides

<<agent>>

QoS

Negotiator

negotiate qos

publishes

builds

Concrete

Service

proxy for

Figure 1: Conceptual integration of MUSA and QoS Nego-

tiation components.

parameter for all the Abstract Services (the denomi-

nator).

Then, the Service Negotiator checks if the selected

set of offers at round t meets the constraint, i.e.:

∑

i=1

¯x

i, j

≤ Req QoS (2)

where Req QoS is the user required QoS value, ex-

pressed as an upper bound of an acceptable combina-

tion, and it is assumed to be composed of one QoS

parameter.

3.3 System Integration

Figure 1 shows an overview of the integration be-

tween the architecture of MUSA and the components

for the automatic negotiation. The integration was

possible thanks to a semantic reconciliation:

• MUSA introduces the concept of Abstract Capa-

bility in order to provide a means for describing

a service in abstract terms. The QoS Negotiation

uses Abstract Service (AS) for the same concept.

• A MUSA plan –built for addressing a set of

goals– corresponds to the QoS Negotiation Ab-

stract Workﬂow (AW).

• In MUSA, each Abstract Capability is associated

to a Concrete Capability that encapsulates the in-

structions for invoking a speciﬁc service. Given

that more providers may offer the same function-

ality, in order to distinguish them the QoS Nego-

tiation refers to a speciﬁc Concrete Service (CS).

• Finally, the run-time plan, that will be executed by

the workﬂow engine, corresponds to a Concrete

Workﬂow (CW).

QoS metrics to compute end-to-end QoS values

and aggregation rules, depend both on the types of

LOOP

Conﬁgurator Negotiator

Service

Provider

goals

abstract

workﬂow

execute workﬂow

negotiate QoS

concrete

workﬂow

Orchestrator

Figure 2: Interaction diagram showing the integration of

MUSA and QoS Negotiation components.

QoS, and on the structure of the AW (i.e., its control

ﬂow). In the integrated framework, service selection,

as shown in Figure 2, is carried out before execution

since starting the execution of a Concrete Workﬂow

that can end up without meeting the users’ QoS re-

quirements would result in a waste of computing re-

sources.

Once one or more plans or Abstract Workﬂows

have been generated, a set of concrete capabilities are

mapped to each abstract capability in the workﬂow.

Concrete capabilities are implemented by Web Ser-

vices, and as such they only know about themselves,

and they are not capable of autonomous action, inten-

tional communication, or proactive cooperative be-

havior (Huhns, 2002). So, in order to provide the

middleware with negotiation capabilities, a software

agent approach is adopted as proposed in (Di Napoli,

2009). In fact, software agents possess all of these

meta-capabilities, and they are used to represent ser-

vice providers and service consumers.

4 A MOTIVATING EXAMPLE:

THE SMART TRAVEL SERVICE

A Smart Travel service is a complex distributed com-

posite service acting as a tour operator for organizing

holiday packages and supporting travelers on-the-run.

The user may use the Smart Travel service to orga-

nize a vacation by specifying a set of functional re-

quirements about the kind of desired vacation includ-

ing the geographic area of interest, places of interest,

activities to perform, and a ser of non functional re-

quirements about a budget to spend, or the degree of

service reliability and so on.

Users may express travel preferences supported by

a ﬂexible language and a speciﬁc interface to convey

her goals about: places to visit, activities to do and –in

general– the kind of vacation. The aim is to aggre-

gate heterogeneous touristic services (ﬂights, trans-

ICAART 2017 - 9th International Conference on Agents and Artiﬁcial Intelligence

280

fers, hotels and tickets for museums, for the opera

and for other local events) in a dynamic, open and ge-

ographically distributed environment. Creating new

travel experiences grounds on putting traveler’s re-

quirements at the center of the process.

The system has to organize the corresponding ser-

vices and acts as a local guide for traveler, running on

a personal device.

4.1 Abstract Workﬂow Generation

In the running example goals represent the main in-

strument for the users in order to express their travel-

ing requests. An example could be the goal:

WHEN in sicily THE user SHOULD ADDRESS vis-

iting palermo for at least 3 days.

Besides the functional requirements, quality as-

sets are the fundamental mechanism to increase user’s

ﬂexibility in expressing their expectations. They rep-

resent a powerful instrument to set the expected QoS.

An example of QoS asset is:

the total cost IS LOWER THAN 1500 e.

An example of a goal representing a travel request

is the following:

GO AL to_ vis it_ cit y :

WH EN n um b er_ nig hts _to _ sp e nd ( cit y , nig ht s )

AN D n ig hts > 0

TH E S YS TEM SH AL L A DDR ES S

hot el_ res erv ed ( city )

For instance, HotelReservation is the abstract ca-

pability that identiﬁes the reservation of a generic ho-

tel in a city for a number of nights. It is described as

follows:

cap ab ili ty ( h ot el_ re ser va tio n ,

% s em ant ic d es cri pti on

pre con di t io n ( av ail abl e ( city , d at es )) ,

pos tco ndi ti o n ( h o te l _r ese rve d ( c it y ) ) ,

evo lu tio n ( add ( h o te l _r ese rve d ( c it y ) )),

Clearly, many Concrete Capabilities may refer to

the same abstract capability by offering the service

with different QoS (for example, prices, stars, . . . ).

Here we show the Concrete Capability provided by

Expedia services. The Concrete Capability also spec-

iﬁes technical details for invoking the web-service

front-end.

con cre t e_ c ap a bi l ity ( e xp edi a_h ote l_ r es e rv ati on ,

exten ds ( h ote l_r ese rva tio n )

% s er vice i nte rfa ce

metho d ( https , put ) ,

addre ss ( http :// te r mi nal 2 . e xp edi a . com / x/

mhote ls / r es er ve ) ,

in put ( [

pa ram ( city , str in g ) ,

pa ram ( room , int eg er ) ,

pa ram ( c heckInD at e , da te ) ,

pa ram ( c heckO ut Da te , d at e ) ]) ,

outpu t ([ param ( re ser va tion_ id , s tring ) ]) ,

% p ro toc ols

ser vic e_p rot oco l ( r es t ) ,

req uir e_ a ut h ( oa uth 20 )

According to the available services, agents of

the system are able of producing more plans for a

required goal. The proactive means-end reasoning

works with abstract capabilities, and it adopts a sym-

bolic approach to satisfy the goal from a functional

point of view. Therefore the resulting workﬂow ag-

gregates generic categories of services.

In the context of the Smart Travel service, the

proactive means-end reasoning organizes a trip by

combing a set of traveling acts: visiting a touristic

place, attending a local event, relaxing on a beach/re-

sort/natural place, and moving from a place to another

one. An example of trip is: 1. ﬂight to dest city, 2.

visit for 2 days, 3. move to beach resort, 4. relax 1

day, . . . 13. ﬂight back.

As a consequence the algorithm deduces an ab-

stract workﬂow for arranging the services necessary

for the trip. For instance, ﬂying to a city demands

to book a seat in a ﬂight in a given data, from the

departure city to the destination (ﬂight booking capa-

bility); visiting a city requires to reserve an accom-

modation for the corresponding nights of visit (ho-

tel reservation capability); and so on. The output is a

workﬂow that aggregates some abstract capabilities.

For example, an extract of the workﬂow is the follow-

ing sequence: 1. ﬂight booking, 2. hotel reservation,

3. restaurant booking.

The plan is still abstract because it requires addi-

tional data, for instance about the kind of accommo-

dations, the timetables, and the price. Clearly, many

alternatives exist for each single service, thus poten-

tially leading to a number of combinations.

In order to become operative, it is necessary to

specify, for each category of services, the concrete

service (and therefore its provider) that will be in-

voked. The speciﬁed quality assets help the system

to select concrete services. For instance, the require-

ment about the budget helps the system to discard lux-

ury hotels providers from the list to be contacted. To

this aim, QoS-based service selection plays a central

role. Indeed, in order to address QoS-aware service

composition, it is necessary to select the combination

of services that satisﬁes also the non-functional re-

quirements, expressed as end-to-end QoS values on

the complete plan.

4.2 Service Providers Strategy

The adopted negotiation mechanism is unilateral,

i.e. counteroffers are not proposed by the negotia-

tor. So, in order for the negotiation to converge, the

only strategy the providers can adopt is a concession

Generating and Instantiating Abstract Workﬂows with QoS User Requirements

281

one. Several types of concession strategies in auto-

mated agent negotiation are proposed in the litera-

ture (Faratin et al., 1998), (Lopes and Coelho, 2010).

Here, the concession strategies are modeled as multi-

dimensional Gaussian functions, where each dimen-

sion represents a single QoS attribute to be negotiated

(Rossi et al., 2016). The Gaussian function represents

the provider’s utility of the generated offers, and at

the same time the probability distribution of the of-

fers the provider may generate. The use of Gaussian

functions allows to simulate a stochastic behaviour of

service providers with zero-intelligence, by approx-

imating the trends of a volatile and open market of

services. A Gaussian function G is characterized by

its parameters µ and σ (G(µ, σ)). The best offer in

terms of the provider’s own utility is represented by

the µ value of the Gaussian function, i.e. U(µ) = 1,

and it corresponds to the QoS value of the offer with

the highest probability to be generated. The Gaus-

sian standard deviation σ represents the attitude of the

provider to concede during negotiation, and it deter-

mines its offer reservation value (µ − σ). Hence, big-

ger values of σ correspond to smaller reservation val-

ues, so to more conceding providers. The negotiation

set of a QoS parameter is [µ − σ; µ].

At each negotiation round, each provider gener-

ates, following its probability distribution, a new util-

ity value corresponding to a new offer. If this value

is lower than the one offered at the previous round

and within the negotiation set, then it proposes the

new value. If this value is greater than the one offered

at the previous round, or it is outside the negotiation

set, the provider proposes the same value offered in

the previous round. This strategy allows to simulate

different and plausible behaviours of providers that

prefers not having a consistent loss in utility, even

though when the number of negotiation rounds in-

creases, the probability for the provider to move to-

wards its reservation value increases.

4.3 Negotiating upon Smart Travel QoS

Once MUSA processes the injected user goal for the

Smart Travel example, an Abstract Workﬂow com-

posed of 3 Abstract Services is computed: ﬂight ser-

vice, hotel service, entertainment services. For each

service more providers are available and the nego-

tiation among them takes place in order to select

the combination of Concrete Services that meets the

user’s requirement on the cost parameters. At each

round providers submit their offers, and at the end of

the round the negotiator selects a set of promising of-

fers, one for each Abstract Service, and it checks if

the corresponding cost is less than the required global

values, i.e.,

∑

i=1

¯x

i, j

≤ 1500e.

If no solution is found at round t, negotiation

takes place with all providers at round t + 1. In fact,

since the strategies of negotiators are not known to

the negotiator for the knowledge disclosure assump-

tion, there is no need to discharge providers that could

become more competitive during the negotiation pro-

cess by updating their offered QoS values. If nego-

tiation is successful, a sub-optimal solution is found

w.r.t. the user request. Of course, the length of ne-

gotiation in terms of the negotiation rounds necessary

to reach an agreement, if any, depends on both the

providers’ strategies, and on their attitude to concede,

but also on the distribution of the QoS values among

the component services. The simulation of negotia-

tion upon the QoS price value of the Smart Travel

service is carried out by randomly generating one

Gaussian distribution for each provider, with differ-

ent concession rates, and reservation values. It should

be noted that providers of the same service have the

same optimal QoS value for their offer (i.e., the one

with utility value equal to 1), to simulate that the de-

sired price of a service is an agreed value among the

providers to avoid an unbalanced market. Accord-

ing to their Gaussian distribution, providers generate

their offers at each negotiation round, until they are

informed either of the negotiation success, or of the

negotiation end with a failure. The negotiation suc-

cess is reached when the compositor ﬁnds a composi-

tion of offers with any QoS value solution of Equation

1. Concurrent negotiation with all providers at each

round makes the negotiation time independent from

the number of Abstract Services in the composition,

and of the providers available for each of them.

5 CONCLUSIONS

The paper proposes a QoS based service composition

framework that relies on both AI planning, and au-

tomatic agent negotiation: the ﬁrst allows to gener-

ate abstract workﬂows satisfying user’s goals, while

the second allows to select the service providers able

to satisfy the QoS requirements speciﬁed by the user.

This hybrid approach allows to address the challenges

due to the dynamic nature of an open system pro-

viding services that are created and updated on the

ﬂy. In fact, such a system has the same characteris-

tics of a market driven by the supply and demands of

goods whose non-functional characteristics have val-

ues that cannot be ﬁxed a priori. In fact, they depend

on several factors as the volatility of the market that

may affect providers’ strategies, the nature of the pro-

vided services, and the users’ preferences. In addi-

ICAART 2017 - 9th International Conference on Agents and Artiﬁcial Intelligence

282

tion, the proposed approach allows concurrent nego-

tiations among providers of the same and the different

services required in the composition, making the ne-

gotiation time independent from the number of both

abstract services in the composition, and of service

providers for each abstract service, that is a crucial

requirement in service oriented scenarios.

ACKNOWLEDGEMENTS

This work has been partially supported by the Ital-

ian Ministry of Education University and Research

within the PRIN 2015 Project “Proﬁling and Adap-

tation for User-centered Assistive Robotics” (Ref.

2015KBL78T).

REFERENCES

Alrifai, M. and Risse, T. (2009). Combining global opti-

mization with local selection for efﬁcient QoS-aware

service composition. In Proceedings of the 18th Int.

Conf. on World Wide Web, pages 881–890. ACM.

Ardagna, D. and Pernici, B. (2007). Adaptive service com-

position in ﬂexible processes. IEEE Trans. on Soft-

ware Eng., 33(6):369–384.

Di Napoli, C. (2009). Knowledge Processing and Deci-

sion Making in Agent-Based Systems, chapter Soft-

ware Agents to Enable Service Composition through

Negotiation, pages 275–296. Springer Berlin.

Di Napoli, C., Di Nocera, D., Pisa, P., and Rossi, S.

(2014). A market-based coordinated negotiation for

qos-aware service selection. In Agent-Mediated Elec-

tronic Commerce. Designing Trading Strategies and

Mechanisms for Electronic Markets, volume 187 of

LNBIP, pages 26–40. Springer.

Di Napoli, C., Di Nocera, D., and Rossi, S. (2015). Com-

puting pareto optimal agreements in multi-issue ne-

gotiation for service composition. In Proceedings of

AAMAS 2015, pages 1779–1780.

Faratin, P., Sierra, C., and Jennings, N. R. (1998). Nego-

tiation Decision Functions for Autonomous Agents.

Robotics and Autonomous Systems, 24:3–4.

Huhns, M. N. (2002). Agents as web services. IEEE Inter-

net Computing, 6(4):93–95.

Lau, R. Y. K. (2007). Towards a web services and intelli-

gent agents-based negotiation system for B2B ecom-

merce. Electronic Commerce Research and Applica-

tions, 6(3):260–273.

Lopes, F. and Coelho, H. (2010). Concession Behaviour

in Automated Negotiation, pages 184–194. Springer

Berlin Heidelberg.

Moghaddam, M. and Davis, J. (2014). Service Selection in

Web Service Composition: A Comparative Review of

Existing Approaches, pages 321–346. Springer New

York, New York, NY.

Papazoglou, M., Traverso, P., Dustdar, S., and Leymann, F.

(2007). Service-oriented computing: State of the art

and research challenges. IEEE Computer, 40(11):38–

45.

Paurobally, S., Tamma, V., and Wooldrdige, M. (2007). A

framework for web service negotiation. ACM Trans.

Auton. Adapt. Syst., 2(4).

Rossi, S., Di Nocera, D., and Di Napoli, C. (2016). Recent

Advances in Agent-based Complex Automated Nego-

tiation, volume 638 of Studies in Computational In-

telligence, chapter Gaussian-Based Bidding Strategies

for Service Composition Simulations, pages 193–208.

Springer International Publishing.

Sabatucci, L. and Cossentino, M. (2015). From Means-

End Analysis to Proactive Means-End Reasoning. In

Proceedings of 10th International Symposium on Soft-

ware Engineering for Adaptive and Self-Managing

Systems, Florence, Italy.

Sabatucci, L., Lodato, C., Lopes, S., and Cossentino, M.

(2015). Highly customizable service composition and

orchestration. In Service Oriented and Cloud Comput-

ing, volume 9306 of LNCS, pages 156–170. Springer.

Sabatucci, L., Lopes, S., and Cossentino, M. (2016). A

goal-oriented approach for self-conﬁguring mashup of

cloud applications. In Cloud and Autonomic Comput-

ing (ICCAC), 2015 International Conference on.

Sabatucci, L., Ribino, P., Lodato, C., Lopes, S., and

Cossentino, M. (2013). Goalspec: A goal speciﬁ-

cation language supporting adaptivity and evolution.

In Engineering Multi-Agent Systems, pages 235–254.

Springer.

Shehu, U., Epiphaniou, G., and Safdar, G. A. (2014). A

survey of qos-aware web service composition tech-

niques. International Journal of Computer Applica-

tions, 89(12):10–17.

Siala, F. and Ghedira, K. (2011). A multi-agent selection

of web service providers driven by composite QoS.

In Proc. of 2011 IEEE Symposium on Computers and

Communications (ISCC), pages 55–60. IEEE.

Strunk, A. (2010). Qos-aware service composition: A sur-

vey. In Web Services (ECOWS), 2010 IEEE 8th Euro-

pean Conference on, pages 67–74.

Yan, J., Kowalczyk, R., Lin, J., Chhetri, M. B., Goh,

S. K., and Zhang, J. (2007). Autonomous service level

agreement negotiation for service composition provi-

sion. Future Gener. Comput. Syst., 23(6):748–759.

Yu, T., Zhang, Y., and Lin, K.-J. (2007). Efﬁcient algo-

rithms for web services selection with end-to-end QoS

constraints. ACM Trans. Web, 1(1).

Zeng, L., Benatallah, B., Ngu, A. H., Dumas, M.,

Kalagnanam, J., and Chang, H. (2004). QoS-aware

middleware for web services composition. IEEE

Trans. on Software Engineering, 30(5):311–327.

Generating and Instantiating Abstract Workﬂows with QoS User Requirements

283