Metering and Accounting for Service-oriented Computing?

2011 ◽  
pp. 274-304
Author(s):  
Arun Kumar ◽  
Vikas Agarwal
Keyword(s):  
Business Models ◽  
Service Level ◽  
Management Service ◽  
Service Usage ◽  
Security Systems ◽  
Service Oriented Architectures ◽  
Loosely Coupled ◽  
Tightly Coupled ◽  
Service Oriented ◽  
Prototype Design

Distributed Systems of today have evolved from tightly coupled architectures such as CORBA and DCOM to loosely coupled service-oriented architectures such as Web Services. The success of such architectures depends upon availability of supporting functions such as security, systems management, service level agreements and development environments with associated tooling. An important management component of such an infrastructure is the metering and accounting for service usage which is essential for successful deployments in commercial environments. This paper explores the problem space and presents an architecture that addresses this need. We start by defining taxonomy of services from the perspective of usage metering, charging and business models. We discuss how service usage can be measured, aggregated and communicated in a uniform way. Finally, we report on a prototype design and implementation.

A Framework and Protocols for Service Contract Agreements Based on International Contract Law

2013 ◽  
pp. 216-231
Author(s):  
Michael Parkin ◽  
Dean Kuo ◽  
John Brooke
Keyword(s):  
Service Oriented Architecture ◽  
Contract Law ◽  
Distributed Environment ◽  
Service Usage ◽  
Negotiated Agreements ◽  
Negotiation Protocol ◽  
Loosely Coupled ◽  
Service Oriented ◽  
Geographically Distributed ◽  
Domain Independent

Current protocols to agree to Web/Grid service usage do not have the capability to form negotiated agreements, nor do they take into account the legal requirements of the agreement process. This article presents a framework and a domain-independent negotiation protocol for creating legally binding contracts for service usage in a distributed, asynchronous service-oriented architecture. The negotiation protocol, which builds on a simple agreement protocol to form a multiround “symmetric” negotiation protocol, is based on an internationally recognized contract law convention. By basing our protocol on this convention and taking into account the limitations of an asynchronous messaging environment, we can form contracts between autonomous services across national and juridical boundaries, necessary in a loosely coupled, widely geographically distributed environment such as the Grid.

Distributed Geospatial Processing Services

2011 ◽  
pp. 1186-1193 ◽  
Author(s):  
Carlos Granell ◽  
Laura Díaz ◽  
Michael Gould
Keyword(s):  
Web Services ◽  
Web Service ◽  
Spatial Data ◽  
Geospatial Data ◽  
Service Description ◽  
Service Oriented Architectures ◽  
Data Infrastructure ◽  
Loosely Coupled ◽  
Tightly Coupled ◽  
Geospatial Services

The development of geographic information systems (GISs) has been highly influenced by the overall progress of information technology (IT). These systems evolved from monolithic systems to become personal desktop GISs, with all or most data held locally, and then evolved to the Internet GIS paradigm in the form of Web services (Peng & Tsou, 2001). The highly distributed Web services model is such that geospatial data are loosely coupled with the underlying systems used to create and handle them, and geospatial processing functionalities are made available as remote, interoperable, discoverable geospatial services. In recent years the software industry has moved from tightly coupled application architectures such as CORBA (Common Object Request Broker Architecture?Vinoski, 1997) toward service-oriented architectures (SOAs) based on a network of interoperable, well-described services accessible via Web protocols. This has led to de facto standards for delivery of services such as Web Service Description Language (WSDL) to describe the functionality of a service, Simple Object Access Protocol (SOAP) to encapsulate Web service messages, and Universal Description, Discovery, and Integration (UDDI) to register and provide access to service offerings. Adoption of this Web services technology as an option to monolithic GISs is an emerging trend to provide distributed geospatial access, visualization, and processing. The GIS approach to SOA-based applications is perhaps best represented by the spatial data infrastructure (SDI) paradigm, in which standardized interfaces are the key to allowing geographic services to communicate with each other in an interoperable manner. This article focuses on standard interfaces and also on current implementations of geospatial data processing over the Web, commonly used in SDI environments. We also mention several challenges yet to be met, such as those concerned with semantics, discovery, and chaining of geospatial processing services and also with the extension of geospatial processing capabilities to the SOA world.

Event Processing in Web Service Runtime Environments

2010 ◽  
pp. 284-306 ◽  
Author(s):  
Anton Michlmayr ◽  
Philipp Leitner ◽  
Florian Rosenberg ◽  
Schahram Dustdar
Keyword(s):  
Web Service ◽  
Service Discovery ◽  
Historical Event ◽  
Event Processing ◽  
Service Oriented Architectures ◽  
Loosely Coupled ◽  
Service Invocation ◽  
Runtime Environment ◽  
Service Oriented ◽  
Runtime Environments

Service-oriented Architectures (SOA) and Web services have received a lot of attention from both industry and academia. Services as the core entities of every SOA are changing regularly based on various reasons. This poses a clear problem in distributed environments since service providers and consumers are generally loosely coupled. Using the publish/subscribe style of communication service consumers can be notified when such changes occur. In this chapter, we present an approach that leverages event processing mechanisms for Web service runtime environments based on a rich event model and different event visibilities. Our approach covers the full service lifecycle, including runtime information concerning service discovery and service invocation, as well as Quality of Service attributes. Furthermore, besides subscribing to events of interest, users can also search in historical event data. We show how this event notification support was integrated into our service runtime environment VRESCo and give some usage examples in an application context.

Service-Oriented Architecture

2011 ◽  
pp. 998-1002
Author(s):  
Kwan-Ming Wan ◽  
Pouwan Lei ◽  
Chris Chatwin ◽  
Rupert Young
Keyword(s):  
Web Services ◽  
Service Oriented Architecture ◽  
Core Competencies ◽  
Enterprise Application Integration ◽  
The Internet ◽  
Business Systems ◽  
Loosely Coupled ◽  
Enterprise Application ◽  
Tightly Coupled ◽  
Service Oriented

The established global business environment is under intense pressure from Asian countries such as Korea, China, and India. This forces businesses to concentrate on their core competencies and adopt leaner management structures. The coordination of activities both within companies and with suppliers and customers has become a crucial competitive advantage. At the same time, the Internet has transformed the way in which businesses run. As the Internet becomes a cheap and effective communication channel, businesses are quick to adopt the Web for integrating their systems together and linking them with their suppliers and customers. Current enterprise computing using J2EE (Java 2 Platform, Enterprise Edition) has yielded systems in which the coupling between various components in them are too tight to be effective for ubiquitous B2B (business-to-business) and B2C (business-to-consumer) e-business over the Internet. This approach requires too much agreement and shared context between business systems from different organizations. There is a need to move away from tightly coupled, monolithic systems and toward systems of loosely coupled, dynamically bound components. The emerging technology, Web services, provides the tools to accomplish this integration, but this approach presents many new challenges and problems that must be overcome. In this article, we will discuss the current approaches in enterprise application integration (EAI) and the limitations. There is also a need for service-oriented applications, that is, Web services. Finally, the challenges in implementing Web services are outlined.

Design of Quality Aspects in Service Oriented Architecture through Service Level Agreements

2011 ◽  
pp. 1-21
Author(s):  
Marco Massarelli ◽  
Claudia Raibulet ◽  
Daniele Cammareri ◽  
Nicolò Perino
Keyword(s):  
Service Oriented Architecture ◽  
Service Level ◽  
Application Domain ◽  
Service Level Agreements ◽  
Actual Case ◽  
Service Oriented Architectures ◽  
Quality Aspects ◽  
Service Oriented

This chapter gives a solution to design Service Oriented Architectures which defines and manages Service Level Agreements to enforce Quality of Services and achieves adaptivity at runtime. The validation of this proposed approach is performed through an actual case study in the context of the multimedia application domain.

Service Level Agreements for Real-Time Service-Oriented Infrastructures

2011 ◽  
pp. 133-159
Author(s):  
Roland Kübert ◽  
Georgina Gallizo ◽  
Theodoros Polychniatis ◽  
Theodora Varvarigou ◽  
Eduardo Oliveros ◽  
...  
Keyword(s):  
Cloud Computing ◽  
Grid Computing ◽  
Real Time ◽  
Service Level ◽  
Service Level Agreements ◽  
Real Time Systems ◽  
Service Oriented Architectures ◽  
Time Service ◽  
Service Oriented ◽  
Time Systems

Service Level Agreements (SLAs) are nowadays used as a cornerstone for building service-oriented architectures. SLAs have been closely investigated in the scope of distributed and Grid computing and are now gaining uptake in cloud computing as well. However, most solutions have been developed for specific purposes and are not applicable generally, even though the most approaches propose a general usability. Only rarely have SLAs been applied to real-time systems. The purpose of this chapter is to analyze different fields where SLAs are used, examine the proposed solutions, and investigate how these can be improved in order to better support the creation of real-time service-oriented architectures.

Service Level Agreements for Real-Time Service-Oriented Infrastructures

2012 ◽  
pp. 1836-1862 ◽  
Author(s):  
Roland Kübert ◽  
Georgina Gallizo ◽  
Thodoris Polychniatis ◽  
Theodora Varvarigou ◽  
Eduardo Oliveros ◽  
...  
Keyword(s):  
Cloud Computing ◽  
Grid Computing ◽  
Real Time ◽  
Service Level ◽  
Service Level Agreements ◽  
Real Time Systems ◽  
Service Oriented Architectures ◽  
Time Service ◽  
Service Oriented ◽  
Time Systems

Service Level Agreements (SLAs) are nowadays used as a cornerstone for building service-oriented architectures. SLAs have been closely investigated in the scope of distributed and Grid computing and are now gaining uptake in cloud computing as well. However, most solutions have been developed for specific purposes and are not applicable generally, even though the most approaches propose a general usability. Only rarely have SLAs been applied to real-time systems. The purpose of this chapter is to analyze different fields where SLAs are used, examine the proposed solutions, and investigate how these can be improved in order to better support the creation of real-time service-oriented architectures.

Automatic Determination of Compatibility in Evolving Services

2011 ◽  
Vol 8 (1) ◽  
pp. 21-40 ◽  
Author(s):  
Karin Becker ◽  
Jim Pruyne ◽  
Sharad Singhal ◽  
Andre Lopes ◽  
Dejan Milojicic
Keyword(s):  
Automatic Determination ◽  
Service Oriented Architectures ◽  
Loosely Coupled ◽  
Service Oriented ◽  
Run Time ◽  
The Impact

A major advantage of Service-Oriented Architectures (SOA) is composition and coordination of loosely coupled services. Because the development lifecycles of services and clients are de-coupled, multiple service versions must be maintained to support older clients. Typically versions are managed within the SOA by updating service descriptions using conventions on version numbers and namespaces. In all cases, the compatibility among services descriptions must be evaluated, which can be hard, error-prone and costly if performed manually, particularly for complex descriptions. In this paper, the authors describe a method to automatically determine when two service descriptions are backward compatible. The authors describe a case study to illustrate version compatibility information in a SOA environment and present initial performance overheads. By automatically exploring compatibility information, a) service developers can assess the impact of proposed changes; b) proper versioning requirements can be put in client implementations guaranteeing that incompatibilities will not occur during run-time; and c) messages exchanged in the SOA can be validated to ensure that only expected messages or compatible ones are exchanged.

A LOOSELY COUPLED ASPECT LANGUAGE FOR SOA APPLICATIONS

2008 ◽  
Vol 18 (02) ◽  
pp. 243-262 ◽  
Author(s):  
NABOR C. MENDONÇA ◽  
CLAYTON F. SILVA ◽  
IAN G. MAIA ◽  
MARIA ANDRÉIA F. RODRIGUES ◽  
MARCO TÚLIO O. VALENTE
Keyword(s):  
Service Oriented Architecture ◽  
Service Providers ◽  
Preliminary Evaluation ◽  
Software Developers ◽  
Loosely Coupled ◽  
Tightly Coupled ◽  
Service Oriented ◽  
Execution Platform ◽  
Application Developers ◽  
The Impact

The aspect-oriented programming (AOP) paradigm offers software developers with powerful modularization abstractions to help them explicitly separate design concerns at the source code level. However, the impact of AOP in the service-oriented architecture (SOA) paradigm has been dwarfed by the fact that existing AOP solutions are tightly coupled to a particular programming language, middleware system or execution platform. Clearly, this not only restricts the implementation choices available to application developers, but it also clashes with the heterogeneous and loosely coupled nature of SOA. This paper presents the Web Service Aspect Language (WSAL) that seamlessly integrates AOP and SOA concepts, thus avoiding the drawbacks of existing solutions. In WSAL, aspects themselves are freely specified, implemented and executed as loosely coupled web services. This characteristic allows WSAL aspects to be easily woven into the message flow exchanged between service consumers and service providers, in a way that is completely independent from any particular implementation technology. This paper also reports on the implementation and preliminary evaluation of a prototype aspect weaver for WSAL, which is based on an existing web intermediary technology.

Software Architecture Patterns in Big Data

2020 ◽  
pp. 90-110
Author(s):  
Serkan Ayvaz ◽  
Yucel Batu Salman
Keyword(s):  
Big Data ◽  
Software Architecture ◽  
Software Systems ◽  
Software Components ◽  
Entire System ◽  
Service Oriented Architectures ◽  
Tightly Coupled ◽  
Service Oriented

Traditional monolithic systems are composed of software components that are tightly coupled and composed into one unit. Monolithic systems have scalability issues as all components of the entire system need to be compiled and deployed even for simple modifications. In this chapter, the evolution of the software systems used in big data from monolithic systems to service-oriented architectures was explored. More specifically, the challenges and strengths of implementing service-oriented architectures of microservices and serverless computing were investigated in detail. Moreover, the advantages of migrating to service-oriented architectures and the patterns of migration were discussed.

Sign in / Sign up

Export Citation Format

Share Document