Search

Today's entreprise-level applications are often built as an assembly of distributed components that provide the basic services required by the application logic. As the scale of these applications increases, coarse-grained components will need be decoupled and will use message-based communication, often helped by Message-Oriented Middleware or MOMs. In the Java world, a standardized interface exists for MOMs: Java Messaging Service or JMS. And like other middleware, some JMS implementations use clustering techniques to provide some level of performance and fault-tolerance. One such implementation is JORAM, which is open-source and hosted by the ObjectWeb consortium. In this paper, we describe performance modeling of various clustering configurations and validate our model with performance evaluation in a real-life cluster. In doing that, we observed that the resource-efficiency of the clustering methods can be very poor due to local instabilities and/or global load variations. To solve these issues, we provide insight into how to build autonomic capabilities on top of the JORAM middleware. Specifically, we describe a methodology to (i) dynamically adapt the load distribution among the servers (load-balancing aspect) and (ii) dynamically adapt the replication level (provisioning aspect). [ABSTRACT FROM AUTHOR]

Distributed multimedia applications are very sensitive to resource variations. An attractive way for dealing with dynamic resource variations consists in making applications adaptive, and even self-adaptive. The objective is to grant applications the ability to observe themselves and their environment, to detect significant changes and to adjust their behavior accordingly. This issue has been the subject of several works; however the proposed solutions lack flexibility and a high-level support that eases the development of adaptive applications. This paper presents PLASMA, a component-based framework for building multimedia applications. PLASMA relies on a hierarchical composition and reconfiguration model which provides the expected support. The experimental evaluation shows that adaptation can be achieved with a very low overhead, while significantly improving QoS of multimedia applications as well as resource usage on mobile equipments. [ABSTRACT FROM AUTHOR]

Component-based programming is a promising approach to distributed application development [1]. It encourages software reuse and promotes the separation (as in aspect-oriented programming[5]) between the components΄ business implementations and the code managing the used system services. One system service of particular importance to the distributed computing domain is replication. [ABSTRACT FROM AUTHOR]

This paper describes a capability-based access control mechanism implemented on a Java environment. In this scheme, access to objects is controlled by means of software capabilities that can be exchanged between mutually suspicious interacting applications. Each application defines the access control rules that must be enforced when interacting with other applications. The definition of access right is managed as a non-functional aspect in the sense it is completely separated from the application code, thus enforcing modularity and ease of expression. It is described in an extended Interface Definition Language (IDL) at the interface level. We have experimented with two prototypes that show how this access control mechanism can be efficiently implemented on a standard Java environment. [ABSTRACT FROM AUTHOR]

Support for cooperative distributed applications is an important direction of computer systems research involving developments in operating systems, programming languages and databases. One emerging model for the support of cooperative distributed applications is that of a distributed shared universe organized as a set of objects shared by concurrent activities. While many experimental distributed object-oriented systems have been designed and implemented (Gothic [Banâtre91], Clouds [Dasgupta90], Emerald [Hutchinson87], Argus [Liskov85]), few have addressed the development of protected applications in such an environment (Melampus [Luniewski91], Birlix [Kowalski90]). In the Guide project, we have designed and implemented a distributed system that not only intends to support the above model, but also provides mechanisms for the development of protected cooperative applications. The advantages of the provided mechanisms are that they allow the cooperation of mutually suspicious users, that protection does not rely on the safety of the code produced by the compilers and that their implementation does not severely degrade object addressing performance. Protection in the Guide system is based on access lists and visibility restrictions on objects. A prototype version of the system has been implemented using the Mach 3.0 micro-kernel as a base. Some simple applications have also been developed. More elaborate tools that allow the configuration of protected applications are to be implemented. [ABSTRACT FROM AUTHOR]