This work presents an infrastructure that simplifies the development of distributed applications that can adapt automatically to nonfunctional properties of their components and of their execution environment. This in...
详细信息
This work presents an infrastructure that simplifies the development of distributed applications that can adapt automatically to nonfunctional properties of their components and of their execution environment. This infrastructure, based on the programming language Lua and on CORBA, allows applications to select dynamically the components that best suit their requirements, to verify whether the system is satisfying these requirements, and to react, when appropriate, to variations in the nonfunctional properties of the services in use. We use CORBA's trading service to support dynamic component selection. An extensible monitoring facility supports monitoring of dynamically defined requirements. We use the Lua language to specify adaptation strategies, and a smart proxy mechanism to apply these strategies.
Scaling applications to large networks and an increasing number of users has been for years a technical challenge. Today, technologies are well known to scale applications to local networks but scaling to large networ...
详细信息
Scaling applications to large networks and an increasing number of users has been for years a technical challenge. Today, technologies are well known to scale applications to local networks but scaling to large networks with high latency is still a challenge. The DLBS (dynamic load balancing service) brings new solutions regarding large scale load balancing for middleware based applications. DLBS offers a multi-criteria and easily customizable load balancing service. It consists of a scalable monitoring infrastructure, a connection manager (integrated into the middleware) and customizable load balancing strategies. Implementation of a low level service requires in order to stay efficient to avoid the necessity for high overhead. DLBS aims to be a generic load balancing service and an easy and efficient portability with a CORBA object request broker has been possible thanks to aspect oriented programming.
Just as the remote procedure call (RPC) turned out to be a very effective OS abstraction in building client-server applications over LANs, type-based publish-subscribe (TPS) can be viewed as a high-level candidate abs...
详细信息
Just as the remote procedure call (RPC) turned out to be a very effective OS abstraction in building client-server applications over LANs, type-based publish-subscribe (TPS) can be viewed as a high-level candidate abstraction for building peer-to-peer (P2P) applications over WANs. This paper relates our preliminary, though positive, experience of implementing and using TPS over JXTA, which can be viewed as the P2P counterpart to sockets. We show that, at least for P2P applications with the Java type model, TPS provides a high-level programming support that ensures type safety and encapsulation, without hampering the decoupled nature of these applications. Furthermore, the loss of flexibility (inherent to the use of any high level abstraction) and the performance overhead, are negligible with respect to the simplicity gained by using TPS.
The coordination paradigm has been used extensively as a mechanism for software composition and integration. However, relatively little work has been done for the cases where the software components involved have real...
详细信息
The coordination paradigm has been used extensively as a mechanism for software composition and integration. However, relatively little work has been done for the cases where the software components involved have real-time requirements. The paper presents an extension to a state-of-the-art controller event-driven coordination language with real-time capabilities. It then illustrates the expressiveness of the proposed extensions by means of modeling a distributed multimedia application. Finally, it discusses how these extensions can be supported by the underlying architecture.
This paper proposes a middleware for home networks, called Virtual Networked Appliance (VNA) architecture, in which the service description method and the Service to Service (S2S) communication mechanism are separated...
详细信息
This paper proposes a middleware for home networks, called Virtual Networked Appliance (VNA) architecture, in which the service description method and the Service to Service (S2S) communication mechanism are separated in an orthogonal way. Through the separation, VNA architecture solved the following two problems of existing middleware technologies: aspect violation and middleware fragmentation. In this paper, we first clarify the two problems and their relationship. Then, we describe the proposed middleware architecture as a solution from the viewpoint of the overall configuration and the S2S communication mechanism.
Mobile agents are computer programs that act autonomously on behalf of a user and travel through a network of heterogeneous machines. To enable mobile agent technology for e-business, transaction support needs to be p...
详细信息
Mobile agents are computer programs that act autonomously on behalf of a user and travel through a network of heterogeneous machines. To enable mobile agent technology for e-business, transaction support needs to be provided, in particular execution atomicity. Execution atomicity ensures that either all operations of the agent succeed, or none at all, and needs to be ensured also in the face of infrastructure failures. We distinguish between blocking and non-blocking solutions for transactional mobile agents, i.e., mobile agents, that execute as a transaction. The approach presented in the paper is non-blocking. A non-blocking transactional mobile agent execution has the important advantage, that it can make progress despite failures.
Configuring distributed applications at deployment time requires the introduction of high-level features such as transaction and synchronization into application code. Component models like CORBA Component Model (CCM)...
详细信息
Configuring distributed applications at deployment time requires the introduction of high-level features such as transaction and synchronization into application code. Component models like CORBA Component Model (CCM) or Enterprise Java Beans (EJB) allow programmers to declare in deployment descriptors which services have to be plugged into components. However, these approaches do not allow a dynamic integration of new services. In this paper, we propose a reflexive approach allowing service integration into a component at runtime. When a new service is added to a component, the combination with existing services is managed dynamically by the platform.
In this paper we describe a software infrastructure that unifies replication and transaction processing in three-tier architectures and, thus, provides high availability and fault tolerance for enterprise applications...
详细信息
In this paper we describe a software infrastructure that unifies replication and transaction processing in three-tier architectures and, thus, provides high availability and fault tolerance for enterprise applications. The infrastructure is based on the Fault Tolerant CORBA and CORBA Object Transaction Service standards, and works with commercial-off-the-shelf application servers and database systems. The infrastructure replicates the application servers to protect the business logic processing. In addition, it replicates the transaction coordinator which renders the two-phase commit protocol non-blocking and, thus, avoids potentially long service disruptions caused by coordinator failure. The infrastructure handles the interactions between the application servers and the database servers through replicated gateways that prevent duplicate requests from reaching the database servers. The infrastructure implements client-side automatic failover mechanisms, which guarantees that clients know the outcome of the requests that they have made. The infrastructure starts the transactions at the application servers, and retries aborted transactions, caused by process or communication failures, automatically on the behalf of the clients.
We argue that joint administration of access policies for a dynamic coalition formed by autonomous domains requires that these domains set up a coalition authority that distributes attribute certificates authorizing a...
详细信息
We argue that joint administration of access policies for a dynamic coalition formed by autonomous domains requires that these domains set up a coalition authority that distributes attribute certificates authorizing access to policy objects (e.g., ACLs). Control over the issuance of such certificates is retained by member domains separately holding shares of the joint coalition authority's private key with which they sign the attribute certificates. Hence, any (proper) subset of the member domains need not be trusted to protect the private key. However, application servers that implement joint administration of access policies based on attribute certificates must trust all the signers of those certificates, namely all member domains of the coalition. To capture these trust relations we extend existing access control logics and show that the extensions are sound. To reason about joint administration of access policies, we illustrate an authorization protocol in our logic for accessing policy objects using threshold attribute certificates.
In this paper, we argue that there is a need for an event-based middleware to build large-scale distributed systems. Existing publish/subscribe systems still have limitations compared to invocation-based middlewares. ...
详细信息
In this paper, we argue that there is a need for an event-based middleware to build large-scale distributed systems. Existing publish/subscribe systems still have limitations compared to invocation-based middlewares. We introduce Hermes, a novel event-based distributed middleware architecture that follows a type- and attribute-based publish/subscribe model. It centres around the notion of an event type and supports features commonly known from object-oriented languages like type hierarchies and super-type subscriptions. A scalable routing algorithm using an overlay routing network is presented that avoids global broadcasts by creating rendezvous nodes. Fault-tolerance mechanisms that can cope with different kinds of failures in the middleware are integrated with the routing algorithm resulting in a scalable and robust system.
暂无评论