An integration experience of a software architecture and a monitoring infrastructure to deploy applications with non‐functional requirements in computing grids

Resource management is an important aspect to consider regarding applications that might have different non‐functional or operational requirements, when running in distributed and heterogeneous environments. In this context, it is necessary to provide the means to specify the required resource constraints and an infrastructure that can adapt the applications in light of the changes in resource availability. We adopted a contract‐based approach to describe and maintain parallel applications that have non‐functional requirements in a Computing Grid context, called ZeliGrid. To form the supporting infrastructure we have designed a software architecture that integrates some of the Globus services, the LDAP and the NWS monitoring services. Some modules that map the contract approach into software artifacts were also integrated to this architecture. This paper addresses the architecture and integration issues of our approach, as well as how we put the pieces together highlighting deployment and implementation details, which have to consider diverse aspects such as monitoring, security and dynamic reconfiguration. Copyright © 2010 John Wiley & Sons, Ltd.     

Dimensions of coupling in middleware

It is well accepted that different types of distributed architectures require different degrees of coupling. For example, in client‐server and three‐tier architectures, application components are generally tightly coupled, both with one another and with the underlying middleware. Meanwhile, in off‐line transaction processing, grid computing and mobile applications, the degree of coupling between application components and with the underlying middleware needs to be minimized. Terms such as ‘synchronous’, ‘asynchronous’, ‘blocking’, ‘non‐blocking’, ‘directed’, and ‘non‐directed’ are often used to refer to the degree of coupling required by an architecture or provided by a middleware. However, these terms are used with various connotations. Although various informal definitions have been provided, there is a lack of an overarching formal framework to unambiguously communicate architectural requirements with respect to (de‐)coupling. This article addresses this gap by: (i) formally defining three dimensions of (de‐)coupling; (ii) relating these dimensions to existing middleware; and (iii) proposing notational elements to represent various coupling integration patterns. This article also discusses a prototype that demonstrates the feasibility of its implementation. Copyright © 2009 John Wiley & Sons, Ltd.     

A lightweight middleware framework for vehicle networking application

There is a growing need for Vehicle Networking Applications (VNAs) development that does not require users to learn the details of VNA data processing and message transfer. VNAs have some special requirements differing from other general‐purpose applications, such as real‐time performance, extensibility, compatibility, and reusability. To meet with these requirements of the VNAs, we propose a lightweight middleware framework for VNAs in this article. In the middle framework, we design multi‐layer middleware architecture to separate VNAs from the software platform and to improve the adaptability for the heterogeneous network and various vehicle networking communication protocols. Meanwhile, the middleware architecture consists of fixed and exchangeable modules to improve the middleware reusability. And the component bus is presented in a framework to standardize component interfaces to improve the extensibility of middleware. The framework has an efficient and simple structure to guarantee the real‐time performance of data processing and message transferring. This middleware also provides a uniform communication mechanism to be compatible with other existing middleware. In this article, we describe the design ideas and the composition of each module in the middleware framework, and analyze the data flow in communication process. We also develop the middleware prototypes to verify the feasibility of the middleware framework. Copyright © 2015 John Wiley & Sons, Ltd.     

Adaptability mechanisms for autonomic system implementation with AAOP

This paper presents a new approach to implementing an adaptability loop in Autonomic Computing (AC) systems, which is based on adaptable aspects. The approach utilizes the concept of adaptable aspect‐oriented programming (AAOP) in which a set of AOP aspects is used to run an application in the manner specified by its adaptability strategy. We present a model execution environment based on this concept, enabling the execution of applications with applied adaptability strategies. In the AAOP‐based AC system, the application is instrumented with aspects selected by the system from a set of all available aspects (sensors, effectors, and goal aspects) in such a way that the system can monitor and manage the application. This model can be used to implement systems that are able to monitor an application and its execution environment, and perform actions such as changing the current set of non‐functional constraints in response to changes in the application or its environment. The model can be used for various types of non‐functional goals, in various programming languages, both in centralized and distributed environments. This paper describes its Java‐based implementation and non‐functional goals referring to resource management. As a consequence, the application uses resources in a way specified in its adaptability strategy. Resource consumption management logic is transparent for the application, meaning that no modifications in the application source code are needed. Copyright © 2010 John Wiley & Sons, Ltd.     

State‐of‐the‐Art Report on Temporal Coherence for Stylized Animations

Non‐photorealistic rendering (NPR) algorithms allow the creation of images in a variety of styles, ranging from line drawing and pen‐and‐ink to oil painting and watercolour. These algorithms provide greater flexibility, control and automation over traditional drawing and painting. Despite significant progress over the past 15 years, the application of NPR to the generation of stylized animations remains an active area of research. The main challenge of computer‐generated stylized animations is to reproduce the look of traditional drawings and paintings while minimizing distracting flickering and sliding artefacts present in hand‐drawn animations. These goals are inherently conflicting and any attempt to address the temporal coherence of stylized animations is a trade‐off. This state‐of‐the‐art report is motivated by the growing number of methods proposed in recent years and the need for a comprehensive analysis of the trade‐offs they propose. We formalize the problem of temporal coherence in terms of goals and compare existing methods accordingly. We propose an analysis for both line and region stylization methods and discuss initial steps towards their perceptual evaluation. The goal of our report is to help uninformed readers to choose the method that best suits their needs, as well as motivate further research to address the limitations of existing methods.     

CORBA request portable interceptors: analysis and applications

Interceptors are an emerging middleware technology enabling the addition of specific network‐oriented capabilities to distributed applications. By exploiting interceptors, developers can register code within interception points, extending the basic middleware mechanisms with specific functionality, e.g. authentication, flow control, caching, etc. Notably, these extensions can be achieved without modifying either the application or the middleware code. In this paper we report the results of our experiences with CORBA request portable interceptors. In particular, we point out (i) the basic mechanisms implementable by these interceptors, i.e. request redirection and piggybacking and (ii) we analyze their limitations. We then propose a proxy‐based technique to overcome the interceptors' limitations. Successively, we present a performance analysis carried out on three Java‐CORBA platforms currently implementing the portable interceptors specification. Finally, we conclude our work with a case study in which portable interceptors are used to implement the fault‐tolerant CORBA client invocation semantic without impacting on the client application code and on the CORBA ORB. We also release fragments of Java code for implementing the described techniques. Copyright © 2003 John Wiley & Sons, Ltd.     

Non‐smooth structured control design with application to PID loop‐shaping of a process

Feedback controllers with specific structure arise frequently in applications because they are easily apprehended by design engineers and facilitate on‐board implementations and re‐tuning. This work is dedicated to H_∞ synthesis with structured controllers. In this context, straightforward application of traditional synthesis techniques fails, which explains why only a few ad hoc methods have been developed over the years. In response, we propose a more systematic way to design H_∞ optimal controllers with fixed structure using local optimization techniques. Our approach addresses in principle all those controller structures which can be built into mathematical programming constraints. We apply non‐smooth optimization techniques to compute locally optimal solutions, and provide practical tests for descent and optimality. In the experimental part we apply our technique to H_∞ loop‐shaping proportional integral derivative (PID) controllers for MIMO systems and demonstrate its use for PID control of a chemical process. Copyright © 2007 John Wiley & Sons, Ltd.     

Arcademis: a framework for object‐oriented communication middleware development

This paper presents Arcademis, a Java‐based framework for communication middleware development. Arcademis consists of a set of abstract classes, interfaces and concrete components that define the general architecture of middleware systems. Its main objective is to support the implementation of non‐monolithic and easily configurable middleware platforms. Arcademis can be used by middleware developers to deploy systems that meet the requirements of a particular network or technology. Instances of Arcademis can also be customized by distributed systems engineers to meet the requirements of a particular application. For example, new transport protocols, connection management policies, authentication algorithms or invocation semantics can be easily configured in middleware platforms derived from Arcademis. In order to illustrate the use of the framework, the paper describes the RME system, a middleware derived from Arcademis that adds a remote method invocation service to the CLDC configuration of Java 2 Micro Edition (J2ME). Copyright © 2006 John Wiley & Sons, Ltd.     

一种基于中间件的可信软件保护模型

软件的可信性是可信计算的研究热点之一。首先描述了可信计算平台和可信平台模块的基本概念,接着结合安全中间件和可信计算模型,在现有的PC体系结构下,提出了一种具体的基于中间件的可信软件保护模型,着重介绍了新模型的体系结构和系统组成,最后通过实例对软件保护机制进行了详细的说明。新模型具有通用性强和易于实现的特点,对于软件可信性保证的研究以及软件可信保护系统的建立具有一定的意义。     

Frameworks compiled from declarations: a language‐independent approach

Programming frameworks are an accepted fixture in the object‐oriented world, motivated by the need for code reuse, developer guidance and restriction. A new trend is emerging where frameworks require domain experts to provide declarations using a domain‐specific language, influencing the structure and behaviour of the resulting application. These mechanisms address concerns such as user privacy. Although many popular open platforms such as Android are based on declaration‐driven frameworks, current implementations provide ad hoc and narrow solutions to concerns raised by their openness to non‐certified developers. Most widely used frameworks fail to address serious privacy leaks and provide the user with little insight into application behaviour. To address these shortcomings, we show that declaration‐driven frameworks can limit privacy leaks, as well as guide developers, independently from the underlying programming paradigm. To do so, we identify concepts that underlie declaration‐driven frameworks and apply them systematically to an object‐oriented language, Java and a dynamic functional language, Racket. The resulting programming framework generators are used to develop a prototype mobile application, illustrating how we mitigate a common class of privacy leaks. Finally, we explore the possible design choices and propose development principles for developing domain‐specific language compilers to produce frameworks, applicable across a spectrum of programming paradigms. Copyright © 2016 John Wiley & Sons, Ltd.     

GMarte: Grid middleware to abstract remote task execution

Grid computing technologies are now being largely deployed with the widespread adoption of the Globus Toolkit as the industrial standard Grid middleware. However, its inherent steep learning curve discourages the use of these technologies for non‐experts. Therefore, to increase the use of Grid computing, it is important to have high‐level tools that simplify the process of remote task execution. In this paper we introduce a middleware, developed on top of the Java Commodity Grid, which offers an object‐oriented, user‐friendly application programming interface, from the Java language, which eases remote task execution for computationally intensive applications. Copyright © 2006 John Wiley & Sons, Ltd.     

OpenCOPI: middleware integration for Ubiquitous Computing

In this paper, we present OpenCOPI (Open COntext Platform Integration), a Service-Oriented Architecture-based middleware platform that supports the integration of services provided by distinct sources, ranging from services offered by simple systems to more complex services provided by context-provision middleware. OpenCOPI offers selection and composition mechanisms to, respectively, select and compose services provided by different sources, considering applications of both Quality of Service and Quality of Context requirements. It also offers an adaptation mechanism that enables to adapt the application execution due to service failures, service quality fluctuation and user mobility. OpenCOPI allows the definition of applications in a higher abstraction level by the specification of a semantic workflow that contains abstract activities. This paper illustrates the use of OpenCOPI in an application from the Gas & Oil Industry and it also shows the evaluation of the main mechanisms of OpenCOPI: the service selection, composition, adaptation and workflow execution.     

A middleware‐transparent approach to developing distributed applications

An innovative middleware‐transparent approach to developing distributed applications is presented. The approach uses an aspect‐oriented software development technique to separate an application's middleware‐independent functionality from its middleware‐specific functionality. Application elements that are specific to the middleware are localized in aspects that can be seamlessly integrated into middleware‐independent application designs. The middleware‐transparent approach is used to decouple business functionality from middleware‐specific functionality. The decoupling allows developers to change middleware application elements without significantly modifying business functionality. Middleware technologies such as Java Remote Method Invocation (RMI), Jini, Simple Object Access Protocol (SOAP) remote procedure call (RPC) and .Net are used as examples to illustrate the approach. Copyright © 2005 John Wiley & Sons, Ltd.     

Zorilla: a peer‐to‐peer middleware for real‐world distributed systems

The inherent complex nature of current distributed computing architectures hinders the widespread adoption of these systems for mainstream use. In general, users have access to a highly heterogeneous set of compute resources, which may include clusters, grids, desktop grids, clouds, and other compute platforms. This heterogeneity is especially problematic when running parallel and distributed applications. Software is needed which easily combines as many resources as possible into one coherent computing platform. In this paper, we introduce Zorilla: peer‐to‐peer (P2P) middleware that creates a single distributed environment from any available set of compute resources. Zorilla imposes minimal requirements on the resource used, is platform independent, and does not rely on central components. In addition to providing functionality on bare resources, Zorilla can exploit locally available middleware. Zorilla explicitly supports distributed and parallel applications, and allows resources from multiple sites to cooperate in a single computation. Zorilla makes extensive use of both virtualization and P2P techniques. We will demonstrate how virtualization and P2P combine into a simple design, while enhancing functionality and ease of use. Together, these techniques bring our goal a step closer: transparent, easy use of resources, even on very heterogeneous distributed systems. Copyright © 2011 John Wiley & Sons, Ltd.     

面向银行的一种中间件的前后处理过程

银行风险数据处理中间件是一种主要采用数据集市技术来支持银行各种风险监管系统的高层应用中间件。本文首先探讨了提出银行风险数据处理中间件的客观原因和对其进行研究的意义,构建出了中间件系统的体系结构,详细描述了各主要功能模块,并着重设计了面向前端和后端的应用服务接口,最后给出了中间件系统的一个应用实例。中间件系统提炼和封装了共同的银行风险数据处理逻辑,为前端各种风险管理应用提供统一的服务接口和平台,大大缩小了银行风险管理系统的开发周期和开发成本。     

Designing a resource broker for heterogeneous grids

Grids provide uniform access to aggregations of heterogeneous resources and services such as computers, networks and storage owned by multiple organizations. However, such a dynamic environment poses many challenges for application composition and deployment. In this paper, we present the design of the Gridbus Grid resource broker that allows users to create applications and specify different objectives through different interfaces without having to deal with the complexity of Grid infrastructure. We present the unique requirements that motivated our design and discuss how these provide flexibility in extending the functionality of the broker to support different low‐level middlewares and user interfaces. We evaluate the broker with different job profiles and Grid middleware and conclude with the lessons learnt from our development experience. Copyright © 2007 John Wiley & Sons, Ltd.     

Peer-to-Peer and fault-tolerance: Towards deployment-based technical services

For effective components, non-functional aspects must be added to application functional code. Likewise, enterprise middleware and component platforms, in the context of Grids, services must be deployed at execution in component containers in order to implement those aspects without modifications in the application code.This paper proposes an architecture for defining, configuring, and deploying such Technical Services in a Grid platform.     

Distributed computing with Triana on the Grid

In this paper, we describe Triana, a distributed problem‐solving environment that makes use of the Grid to enable a user to compose applications from a set of components, select resources on which the composed application can be distributed and then execute the application on those resources. We describe Triana's current pluggable architecture that can support many different modes of operation by the use of flexible writers for many popular Web service choreography languages. We further show, that the Triana architecture is middleware‐independent through the use of the Grid Application Toolkit (GAT) API and demonstrate this through the use of a GAT binding to JXTA. We describe how other bindings being developed to Grid infrastructures, such as OGSA, can seamlessly be integrated within the current prototype by using the switching capability of the GAT. Finally, we outline an experiment we conducted using this prototype and discuss its current status. Copyright © 2005 John Wiley & Sons, Ltd.     

面向多终端异构系统的中间件平台体系结构研究

针对移动终端自身能力不足和多终端异构系统的差异造成重复开发的弊端,通过对中间件平台架构的研究,采用中间件技术迁移能力屏蔽差异,提出一种面向多终端异构系统的中间件平台架构.将“能力+中间件+终端应用”的服务模式与SOA、OSGi、数据交互技术相结合,实现该平台的模块化、松耦合,提供一种高效、低成本、跨平台的开发方式.通过该平台架构上开发的一种服务验证了平台架构的正确性.