DYNAMICALLY RECONFIGURABLE DATA-INTENSIVE SERVICE

COMPOSITION

Onyeka Ezenwoye, Salome Busi

Electrical Engineering and Computer Science Department, South Dakota State University, Brookings, South Dakota, U.S.A.

S. Masoud Sadjadi

School of Computing and Information Sciences, Florida International University, Miami, Florida, U.S.A.

Keywords:

Service composition models, Scientiﬁc workﬂow, Adpaptability, Dynamic reconﬁguration, Choreography,

Orchestration.

Abstract:

The distributed nature of services poses signiﬁcant challenges to building robust service-based applications. A

major aspect of this challenge is ﬁnding a model of service integration that promotes ease of dynamic recon-

ﬁguration, in response to internal and external stimuli. Centralized models of composition are not conducive

for data-intensive applications such as those in the scientiﬁc domain. Decentralized compositions are more

complicated to manage especially since no service has a global view of the interaction. In this paper we iden-

tify the requirements for dynamic reconﬁguration of data-intensive composite services. A hybrid composition

model that combines the attributes of centralization and decentralization is proposed. We argue that this model

promotes dynamic reconﬁguration of data-intensive service compositions.

1 INTRODUCTION

A system is a set of interrelated components that are

interacting in an interdependent manner to accom-

plish a common goal. A service can be deﬁned as the

function performed or the behavior exhibited by a sys-

tem. Service Oriented Architecture (Bichler and Lin,

2006) provides service based computing which deals

with the interactions between loosely coupled, au-

tonomous and replaceable components that are avail-

able over a heterogeneous network. The Web Service

paradigm (Kreger, 2001; Gottschalk et al., 2002) is

one realization of the Service Oriented Architecture.

With Web services, distributed applications can

be encapsulated as self-contained, discoverable and

Internet-accessible software components that can be

integrated to create other applications. Web services

are characterized by a precise separation of service in-

terface description, implementation, and binding, as

well as standardized and declarative message-based

interactions. The family of speciﬁcations that make

up the Web service standards includes a speciﬁca-

tion for composition (Andrewset al., 2003; Kavantzas

et al., 2005) of existing services to create new higher-

level services. These composition languages deﬁne

abstractions in the form of workﬂows (Becker et al.,

2002) that represent composite services. The exe-

cutable abstractions model the interaction between

the integrated services. Service composition lan-

guages are either general-purpose (Andrews et al.,

2003; Kavantzas et al., 2005) or domain-speciﬁc,

as typically seen in scientiﬁc applications (Yu and

Buyya, 2005)

The distributed nature of services poses signiﬁ-

cant problems to building robust service-based appli-

cations. Addressing issues concerning dynamic re-

conﬁguration of services collaborating in multiple ap-

plication scenarios, to make them more dependable, is

a challenging task. This is because the integration of

multiple services introduces new levels of complex-

ity in management. Due to the autonomy of services

involved in a composition, the management of com-

posite services cannot extend into the administrative

boundaries of individual services (Vogels, 2003; Di-

alani et al., 2002). Thus the composed service has no

inﬂuence over the factors affecting quality of service

provision at the level of the atomic service. This con-

tributes to the transiency of services, which may fail

due to problems in their environment such as faults

and resource starvation. Also, since services interact-

125

Ezenwoye O., Busi S. and Masoud Sadjadi S.

DYNAMICALLY RECONFIGURABLE DATA-INTENSIVE SERVICE COMPOSITION.

DOI: 10.5220/0002852101250130

In Proceedings of the 6th International Conference on Web Information Systems and Technology (WEBIST 2010), page

ISBN: 978-989-674-025-2

ing in a composition are distributed, there is the added

problems concerning the unmanaged nature of the In-

ternet.

The increasing use of software as a service (Zhang

et al., 2004; Benslimane et al., 2008; Armbrust et al.,

2009; Grossman, 2009) has also lead to increasingly

complex and data-intensive service aggregations. The

highly available nature of some of these applications

demands that they remain operational and rapidly re-

sponsiveeven when failures disrupt some of the nodes

in the system (Birman et al., 2004; Deelman and Gil,

2006; Lindholm, 2007). Thus, there is a need to

deliver reliable service compositions with attributes

that cover functional correctness, performance and

dependability (Ouzzani and Bouguettaya, 2004; Gil

et al., 2007), especially since current Web services

standards provide limited constructs for specifying

exceptional behavior and recovery actions. It is dif-

ﬁcult for developers of composite services to antici-

pate and account for all the dynamics of such interac-

tions. This is especially true for data-intensive service

compositions where data movement and management

is particularly problematic. There is therefore a need

for service compositions that are dynamically recon-

ﬁgurable to make them more robust and dependable.

Addressing these challenges calls for the development

of novel techniques to modeling and management of

composite services.

In this paper, we identify the some key require-

ments of adaptive data-intensive service composition.

We also propose a model of service composition that

supports dynamic reconﬁguration. The rest of this pa-

per is structured as follows. Section 2 provides an

overviewof service composition models. In Section 3

we discuss the requirements for dynamically recon-

ﬁgurable service composition. Finally, some conclud-

ing remarks are provided in Section 4.

2 COMPOSITION MODELS

Composite services are an aggregation of two or more

services. The composite service is modeled as a graph

where the nodes represent tasks and the edges repre-

sent some composition constraints in the form data

ﬂow or ﬂow control dependencies between tasks. Fig-

ure 1 shows the object-relational model of service

composition. In this model, the composite service

is an aggregation of tasks and the tasks may be im-

plemented by the integrated services. The composite

service itself is a service.

The composite services are described and pub-

lished as service aggregators which are service

providers themselves. The service aggregates model

Composite Task

implemented-by

is-a

Consumer Service

is-a

Provider

Figure 1: Object relationship for service composition.

and coordinate the interactions between the con-

stituent services. The two main service composition

models are orchestration and choreography (Peltz,

2003). In orchestration, the interaction between ser-

vices is coordinated in a centralized manner by a pro-

cess with captures the logic of the interaction between

the services. The logic of the interaction (control and

data dependencies) is encapsulated within the com-

posite service in the form of a workﬂow. The work-

ﬂow is executed in an orchestration engine which ex-

poses the workﬂow (composite) as a service. As il-

lustrated in Figure 2, the order of execution of the in-

tegrated services is controlled by the composite via

control messages (invocations). Data interchange be-

tween the integrated services also passes through the

composite. This model presents some advantages

in that management of the integration is centralized,

however this centralization presents signiﬁcant chal-

lenges to data-intensive compositions and scalabil-

ity (Liu et al., 2002)

Composite

Service

Service Service

data flow

ontrol flow

data flow

ontrol flow

Figure 2: Service Orchestration Model.

In contrast to the orchestration model, service

choreography (Figure 3) involves two or more ser-

vices participating to provide a service, in peer to peer

manner. This model is characterized by decentralized

control and data ﬂow. Here, each service is aware of

its role in the interaction and its immediate partner.

This presents signiﬁcant advantages to scalability and

more efﬁcient data ﬂow. However, this model is dif-

ﬁcult to manage especially in exceptional conditions.

WEBIST 2010 - 6th International Conference on Web Information Systems and Technologies

126

Dynamic reconﬁguration is difﬁcult since no service

has a global view of the overall integration.

Service Service Service

data flow control flow

Figure 3: Service Choreography Model.

To overcome some of the limitations of orches-

tration, some service orchestration platforms do em-

ploy decentralized data ﬂow techniques, as illustrated

in Figure 4. This approach is typically utilized for

data-intensive composition which is often seen in sci-

entiﬁc workﬂow application. In this model, integrated

services also encapsulate data movement and man-

agement logic to facilitate the movement of data in

a peer-to-peer manner. Control ﬂow logic is retained

by the composite thus issues with scalability persist.

Also the composite service constitutes a central point

of fail. Besides, dynamic reconﬁguration is still a

problem since the composite cannot easily be modi-

ﬁed to react to changes in the environment of the in-

teraction.

Composite

Service

Service Service

data flow control flow

Figure 4: Service orchestration with decentralized data

ﬂow.

3 REQUIREMENTS FOR

ADAPTABILITY

Good examples of data-intensive applications are

those found in the domain of scientiﬁc work-

ﬂows (Jaeger et al., 2005; Ezenwoye et al., 2007).

Here service integration is achieved through compos-

ite services which are used to create applications for

coordinated problem solving. Scientiﬁc applications

are both data intensive and computational intensive.

These applications require a number of systems work-

ing together, accessing large amounts of data and an-

alyzing the data in parallel. Scientiﬁc applications

analysis takes long time to complete. Thus it is neces-

sary that the application runs successfully in spite of

changes in execution and the execution environment.

The adaptability of the architecture of such applica-

tions is required to enable reconﬁguration of the sys-

tem. Below we identify the major requirements for

adaptive service composition.

3.1 High-level Composition

Key to the realization of the beneﬁts of service-

oriented computing is the ability to integrate basic

services to create higher-level applications. These

higher-level applications will provide the right level

of abstraction for the non-computer scientists. Thus,

allowing them to concentrate on their domain spe-

ciﬁc work instead of the technical issues of underly-

ing layers. Workﬂow languages permit such aggre-

gation of services to create coarse-grained processes

that constitute a number of related functions. With

such languages, higher-level application can be mod-

eled as graphs where the nodes represent tasks while

the edges represent inter-task dependencies, data ﬂow

or control ﬂow.

Although complex processes can be developed

with general-purpose languages such as Java and

C++, such languages do not provide high-level con-

structs to easily deﬁne processes that represent com-

posite services. High-level composition tools make

it possible for domain specialist to deploy ﬂexible

service-oriented applications. However, current com-

position tools are too cumbersome and complex to al-

low for easy service composition. High-level tools

need to have support for separation of concerns that

would permit aspect-oriented (Kiczales et al., 1997)

techniques, so that aspect weaving capabilities that

address quality of service concerns can be introduced.

This is important so that users can for instance, spec-

ify failure handling policies at a higher level of ab-

straction without having to entangle them within the

application logic.

For higher level service compositions there are

many aspects that need to be incorporated in order to

provide more ﬂexibility, adaptability and reliability in

the system. Some other requirements for higher-level

composition are to provide coordination methods, dy-

namic models and automated service integration and

composition (Papazoglou et al., 2007; Ezenwoye and

Sadjadi, 2006).

3.2 Extensible Recover Mechanisms

Due to the heterogeneous nature of the application

context, failure recovery mechanisms should support

a wide range of failure handling strategies includ-

ing user-deﬁned exception handling. Flexible fail-

ure handling mechanism should allow multiple fault

DYNAMICALLY RECONFIGURABLE DATA-INTENSIVE SERVICE COMPOSITION

127

tolerance techniques and strategies (e.g., retry, mi-

gration, restart and checkpointing) This would permit

each task to select an appropriate fault tolerance tech-

nique among alternatives depending on the character-

istics of the task or the underlying execution environ-

ment (Hwang and Kesselman, 2003) Support for ex-

tensible failure handling mechanisms should be pro-

vided so that it is possible to specify at a high-level,

such diverse failure handling strategies within a re-

covery policy that can be modiﬁed at runtime. Such

an approach would permit a user to deﬁne speciﬁc

exceptions and exception handling since the recovery

mechanism is extensible. However, such mechanisms

should not prevent the developer of the application

from specifying speciﬁc exception handling. Tasks

for which exception handling has been deﬁned within

the application, may be left untouched by the adapta-

tion mechanism, if so desired.

3.3 Robust Data Management

The inherent nature of the infrastructure and envi-

ronment for distributed composite applications means

that the management of data comes with challenges.

The successful execution of applications is depen-

dent on the availability of necessary data. However,

moving an application close to the data may not al-

ways be practical due to insufﬁcient computational

resources at the storage site (Kosar and Livny, 2005),

so data needs to be moved to the applications that

need them and in some cases cleanup operations are

required after application execution. Also, deployed

composite services may be unable to execute due to

the lack of the disk space, requiring that data move-

ment be scheduled and monitored. Thus, the manage-

ment of data is essential through the entire lifecycle

of such distributed applications from creation to ex-

ecution, and result management (Deelman and Cher-

venak, 2008)

Although data is a key component, a lot of em-

phasis is not placed on providing fault tolerance for

tasks related to data requirements. For instance, data

staging tasks are often embedded in computation-

related tasks and reliability efforts are then focused

on the computation tasks even though data access

presents the main bottleneck for data-intensive ap-

plications (Kosar and Livny, 2005) Thus improving

the reliability calls for the decoupling of data stag-

ing and computation activities, and each aspect needs

to be addressed separately (Ranganathan and Foster,

2002; Ezenwoye et al., 2009) Also, infrastructure for

distributed data-intensive composite services needs to

consider data movement as part of the end-to-end per-

formance of the system. Techniques for dynamic

scheduling, caching and data replication should be

used to ensure availability of date. Care must be taken

to make sure they complete successfully and without

any need for human intervention (Kosar and Livny,

2005) Since services are often composed by domain

specialists that are not particularly familiar with per-

formance and fault-tolerance issues of the underlying

layer, constructs for data management need to be sep-

arated from business logic of the composite applica-

tion during development time.

3.4 Modularization

Data-intensive service compositions have a tendency

to be large and complex with multiple cross-cutting

concerns. Facilitating reconﬁguration calls for modu-

larization of composite services into pluggable pieces

that encapsulate various concerns. For instance, re-

covery mechanisms should enable the separation of

failure handling policies from application codes. This

requirement is driven by the dynamic nature of the en-

vironment, and would permit the adaptation of failure

handling policies to changing environments by modi-

fying the high-level policy description. Recovery pol-

icy speciﬁcation, monitoring, exception handling and

data management logic should be modular and exter-

nalized to keep the service composition uncluttered.

This separation also ensures that components are able

to evolve separately.

Also, coding manually various cross-cutting con-

cerns within the application is not a viable solu-

tion because it makes the development much more

complicated. Therefore, generative programming

techniques should be used to apply software pat-

terns (Buschmann et al., 2007) which constitute ab-

stract reusable concepts that can be conﬁgured for a

range of situations. The reuse of these abstract con-

cepts is facilitated by the fact that applications in the

same domains are similar and carry out comparable

functions (Sommerville, 2006).

3.5 A Hybrid Composition Model

In this Section we propose a model of service com-

position to support dynamic reconﬁguration. This

model is a combination of orchestration and chore-

ography models, and overcomes some of the limi-

tations orchestration and choreography. The model

has a composite service, which we will referred to as

the monitor ( Figure 5). The monitor is a compos-

ite which models the logic of the interaction between

the services participating in the choreography. Thus

the monitor has the global view of the interaction be-

tween the interacting services. This component mon-

WEBIST 2010 - 6th International Conference on Web Information Systems and Technologies

128

itors the interactions and intervenes only if necessary

to provide required adaptability to the system. This

monitor node observes the data and control-ﬂow of

the choreography. In case of failure, the monitor in-

tervenes and for instance, assigns the load to another

service and provides it with the information to resume

the task to be performed. This monitor would encap-

sulate the behavioral and recovery policies that allow

for the choreography to be reconﬁgured.

Monitor

Service Service Service

data flow control flow

Figure 5: A hybrid service composition model.

Composite

is-a

Monitor

is-a

Update( )

Service

Notify( )

Figure 6: Object relationship for hybrid composition.

Figure 6 shows the object-relational model for hy-

brid composition. The data stored by the monitor

reﬂects the state of the choreography, therefore the

relationship is the Observer pattern. The Observer

design pattern allows for dependency between object

to be speciﬁed so that when one component changes

state all dependent components are notiﬁed and up-

dated (Gamma et al., 1995) This pattern of behav-

ior is especially important in distributed environments

where services are statefull and long-running. Ser-

vices provide notiﬁcation interfaces that allow for ob-

servers to be updated about state change. In Figure 6,

Monitor is the observer and registers for state change

notiﬁcation with the monitored services in the chore-

ography. Note that the observer in this case does not

constitute a single point of failure since multiple ob-

servers can be used.

4 CONCLUSIONS

In this paper, we presented the orchestration and

choreography service composition models, and

pointed out their limitations. In orchestration, a cen-

tral point of control for both control messages and

data exchange becomes a bottleneck for data inten-

sive applications. While in choreography, the lack of

global view of the system fails to incorporate dynamic

reconﬁguration in the system.

We identiﬁed the requirements for dynamically

reconﬁgurable service compositions for data inten-

sive applications. A hybrid composition model that

combines the positive attributes of orchestration and

choreography is also present. The hybrid model of

service composition supports the dynamic reconﬁgu-

ration for data-intensive applications. This model in-

cludes a monitoring node that has a global view of the

choreography and observe the behavior of services in-

volved in choreography. Reconﬁguration is achieved

through the monitoring component.

ACKNOWLEDGEMENTS

This work was supported in part by the National Sci-

ence Foundation under Grant No. OISE-0730065.

Any opinions, ﬁndings, and conclusions or recom-

mendations expressed in this paper are those of the

authors and do not necessarily reﬂect the views of the

National Science Foundation.

REFERENCES

Andrews, T., Curbers, F., Dholakia, H., Goland, Y., Klein,

J., Leymann, F., Liu, K., Roller, D., Smith, D., That-

tee, S., Trickovic, I., and Weerawarana, S. (2003).

Business process execution language for web services.

Armbrust, M., Fox, A., Joseph, R. G. A., Katz, R., Kon-

winski, A., Lee, G., Patterson, D., Rabkin, A., Sto-

ica, I., and Zaharia, M. (2009). Above the clouds: A

berkeley view of cloud computing. Technical Report

UCB/EECS-2009-28, EECS Department, University

of California, Berkeley.

Becker, J., Gille, M., Muehlen, M. Z., and Gille, D. M.

(2002). Workﬂow application architectures: Classi-

ﬁcation and characteristics of workﬂow-based infor-

mation systems. In in: Fischer, L. (Ed.): Workﬂow

Handbook 2002, Future Strategies, Lighthouse Point,

FL, pages 39–50.

Benslimane, D., Dustdar, S., and Sheth, A. (2008). Ser-

vices mashups: The new generation of web applica-

tions. IEEE Internet Computing, 12(5):13–15.

Bichler, M. and Lin, K.-J. (2006). Service-oriented com-

puting. Computer, 39(3):99–101.

DYNAMICALLY RECONFIGURABLE DATA-INTENSIVE SERVICE COMPOSITION

129

Birman, K. P., van Renesse, R., and Vogels, W. (2004).

Adding high availability and autonomic behavior to

web services. In Proceedings of the 26th Interna-

tional Conference on Software Engineering (ICSE

2004), pages 17–26, Edinburgh, United Kingdom.

IEEE Computer Society.

Buschmann, F., Henney, K., and Schmidt, D. C. (2007).

Pattern-Oriented Software Architecture: A Pattern

Language for Distributed Computing, Volume 4. Wi-

ley.

Deelman, E. and Chervenak, A. (2008). Data management

challenges of data-intensive scientiﬁc workﬂows. In

Proceedings of the Eighth IEEE International Sympo-

sium on Cluster Computing and the Grid, Washington,

DC, USA. IEEE Computer Society.

Deelman, E. and Gil, Y. (2006). Managing large-scale sci-

entiﬁc workﬂows in distributed environments: Expe-

riences and challenges. In Proceedings of the Second

IEEE International Conference on e-Science and Grid

Computing, page 144, Washington, DC, USA. IEEE

Computer Society.

Dialani, V., Miles, S., Moreau, L., Roure, D. D., and Luck,

M. (2002). Transparent fault tolerance for web ser-

vices based architectures. In Eighth International

Europar Conference (EURO-PAR’02), Lecture Notes

in Computer Science, Padeborn, Germany. Springer-

Verlag.

Ezenwoye, O. and Sadjadi, S. M. (2006). Composing ag-

gregate web services in BPEL. In Proceedings of The

44th ACM Southeast Conference, Melbourne, Florida.

Ezenwoye, O., Sadjadi, S. M., Carey, A., and Robinson, M.

(2007). Grid service composition in bpel for scientiﬁc

applications. In Proceedings of the International Con-

ference on Grid computing, high-performAnce and

Distributed Applications, Vilamoura, Algarve, Portu-

gal.

Ezenwoye, O., Viswanathan, B., Sadjadi, S. M., Fong, L.,

Dasgupta, G., and Kalayci, S. (2009). Task decompo-

sition for adaptive data staging in workﬂows for dis-

tributed environments. In Proceedings of the 21st In-

ternational Conference on Software Engineering and

Knowledge Engineering, pages 16–19, Boston, MA.

Gamma, E., Helm, R., Johnson, R., and Vlissides, J.

(1995). Design Patterns: Elements of Reusable

Object-Oriented Software. Addison-Wesley Profes-

sional Computing Series. Addison-Wesley Publishing

Company.

Gil, Y., Deelman, E., Ellisman, M., Fahringer, T., Fox, G.,

Gannon, D., Goble, C., Livny, M., Moreau, L., and

Myers, J. (2007). Examining the challenges of scien-

tiﬁc workﬂows. Computer, 40(12):24–32.

Gottschalk, K. D., Graham, S., Kreger, H., and Snell, J.

(2002). Introduction to web services architecture.

IBM Systems Journal, 41(2):170–177.

Grossman, R. L. (2009). The case for cloud computing. IT

Professional, 11(2):23–27.

Hwang, S. and Kesselman, C. (2003). Gridworkﬂow: A

ﬂexible failure handling framework for the grid. In

Proceedings of The 12th IEEE International Sympo-

sium on High Performance Distributed Computing,

Seattle, Washington.

Jaeger, E., Altintas, I., Zhang, J., Ludscher, B., Pen-

nington, D., and Michener, W. (2005). A scientiﬁc

workﬂow approach to distributed geospatial data pro-

cessing using web services. In Proceedings of the

17th international conference on Scientiﬁc and statis-

tical database management, pages 87–90. Lawrence

Berkeley Laboratory.

Kavantzas, N., Burdett, D., Ritzinger, G., Fletcher, T., La-

fon, Y., and Barreto, C. (2005). Web Services Chore-

ography Description Language. W3C, 1.0 edition.

Kiczales, G., Lamping, J., Menhdhekar, A., Maeda, C.,

Lopes, C., Loingtier, J.-M., and Irwin, J. (1997).

Aspect-oriented programming. In Proceedings Eu-

ropean Conference on Object-Oriented Programming,

volume 1241, pages 220–242. Springer-Verlag.

Kosar, T. and Livny, M. (2005). A framework for reliable

and efﬁcient data placement in distributed computing

systems. Journal of Parallel and Distributed Comput-

ing.

Kreger, H. (2001). Web Services Conceptual Architecture.

IBM Software Group.

Lindholm, K. R. (2007). The user experience of software-

as-a-service applications. Technical Report UCB

iSchool Report 2007-005, The School of Information,

University of California, Berkeley.

Liu, D., Law, K. H., and Wiederhold, G. (2002). Analysis

of integration models for service composition. In Pro-

ceedings of the 3rd international workshop on Soft-

ware and performance, pages 158–165. ACM.

Ouzzani, M. and Bouguettaya, A. (2004). Efﬁcient access

to web services. IEEE Internet Computing, 8(2):34–

44.

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

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

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

Peltz, C. (2003). Web services orchestration and choreog-

raphy. IEEE Computer, 36(10):44–52.

Ranganathan, K. and Foster, I. (2002). Decoupling compu-

tation and data scheduling in distributed data-intensive

applications. In International Symposium on High-

Performance Distributed Computing, Los Alamitos,

CA, USA. IEEE Computer Society.

Sommerville, I. (2006). Software Engineering 8th edition.

Addison-Wesley.

Vogels, W. (2003). Web services are not distributed objects.

IEEE Internet Computing.

Yu, J. and Buyya, R. (2005). A taxonomy of scientiﬁc work-

ﬂow systems for grid computing. SIGMOD Record,

34(3):44–49.

Zhang, L.-J., Li, H., and Lam, H. (2004). Services com-

puting: Grid applications for today. IT Professional,

6(4):5–7.

WEBIST 2010 - 6th International Conference on Web Information Systems and Technologies

130