12760716
Making Web services dependable
Web services offer great promise for integrating and automating software applications within and between enterprises over the Internet. However, ensuring that Web services are dependable, and can satisfy their clients' requests when the clients need them is a real challenge because, typically, a business activity involves multiple Web services and a Web service involves multiple components, each of which must be dependable. In this paper, we describe fault tolerance techniques, including replication, checkpointing, and message logging, in addition to reliable messaging and transaction management for which Web services specifications exist. We discuss how those techniques can be applied to the components of the Web services involved in the business activities to render them dependable.
8961835
Design and Implementation of a Pluggable Fault-Tolerant CORBA Infrastructure
In this paper we present the design and implementation of a Pluggable Fault-Tolerant CORBA Infrastructure that provides fault tolerance for CORBA applications by utilizing the pluggable protocols framework that most CORBA ORBs provide. Our approach does not require any modification to the CORBA ORB, and requires only minimal modification to the application. Moreover, it avoids the difficulty of retrieving and assigning the ORB state by embedding the fault tolerance mechanisms into the ORB. The Pluggable Fault-Tolerant CORBA Infrastructure exhibits similar or better performance than other Fault-Tolerant CORBA systems, while providing strong replica consistency.
11584663
Deterministic scheduling for multithreaded replicas
Replication of objects, processes and components is essential for building reliable distributed systems. However, maintaining replica consistency in the presence of nondeterminism is a challenge. There are many sources of nondeterminism in the applications being replicated. In this paper, we focus on the nondeterminism resulting from multithreading in the applications, and present a deterministic scheduling algorithm for ensuring consistent execution of replicated multithreaded applications.
195350091
Design and implementation of a pluggable fault tolerant CORBA infrastructure
In this paper we present the design and implementation of a Pluggable Fault Tolerant CORBA Infrastructure that provides fault tolerance for CORBA applications by utilizing the pluggable protocols framework that is available for most CORBA ORBS. Our approach does not require modification to the CORBA ORB, and requires only minimal modifications to the application. Moreover; it avoids the difficulty of retrieving and assigning the ORB state, by incorporating the fault tolerance mechanisms into the ORB. The Pluggable Fault Tolerant CORBA Infrastructure achieves performance that is similar to, or better than, that of other Fault Tolerant CORBA systems, while providing strong replica consistency.
8178704
Unification of transactions and replication in three-tier architectures based on CORBA
In this paper, we describe a software infrastructure that unifies transactions and replication in three-tier architectures and provides data consistency and high availability for enterprise applications. The infrastructure uses transactions based on the CORBA object transaction service to protect the application data in databases on stable storage, using a roll-backward recovery strategy, and replication based on the fault tolerant CORBA standard to protect the middle-tier servers, using a roll-forward recovery strategy. The infrastructure replicates the middle-tier servers to protect the application business logic processing. In addition, it replicates the transaction coordinator, which renders the two-phase commit protocol nonblocking and, thus, avoids potentially long service disruptions caused by failure of the coordinator. The infrastructure handles the interactions between the replicated middle-tier servers and the database servers through replicated gateways that prevent duplicate requests from reaching the database servers. It implements automatic client-side failover mechanisms, which guarantee that clients know the outcome of the requests that they have made, and retries aborted transactions automatically on behalf of the clients.
20298520
Increasing the reliability of three-tier applications
In this paper we describe an infrastructure that provides increased reliability for three-tier applications, transparently, using commercial off-the-shelf application servers and database systems. In this infrastructure the application servers are actively replicated to protect the business logic processing. Replicating the transaction coordinator renders the two-phase commit protocol non-blocking and, thus, avoids potentially long service disruptions caused by coordinator failure. A thin interpositioning library provides client-side automatic failover, so that clients know the outcome of their requests. The interaction between the application servers and the database servers is handled through replicated gateways that prevent duplicate requests from reaching the database servers. Aborted transactions, caused by process or communication faults, are automatically retried on the client's behalf.
16063472
On the confidential auditing of distributed computing systems
We propose a confidential logging and auditing service for distributed information systems. We propose a cluster-based TTP (trusted third party) architecture for the event log auditing services, so that no single TTP node can have the full knowledge of the logs, and thus no single node can misuse the log information without being detected. On the basis of a relaxed form of secure distributed computing paradigms, one can implement confidential auditing service so that the auditor can retrieve certain aggregated system information, e.g. the number of transactions, the total volume, the event traces, etc., without having to access the full log data. Similar to the peer relationship of routers to provide global network routing services, the mutually supported, mutually monitored cluster TTP architecture allows independent systems to collaborate in network-wide auditing without compromising their private information.
16792012
Using Traffic Regulation to Meet End-to-End Deadlines in ATM Networks
Considers the support of hard real-time connections in ATM networks. In an ATM network, a set of hard real-time connections can be admitted only if the worst-case end-to-end delays of cells belonging to individual connections are less than their deadlines. There are several approaches to managing the network resources in order to meet the delay requirements of connections. This paper focuses on the use of traffic regulation to achieve this objective. Leaky buckets provide simple and user-programmable means of traffic regulation. An efficient optimal algorithm for selecting the burst parameters of leaky buckets to meet connections' deadlines is designed and analyzed. The algorithm is optimal in the sense that it always selects a set of burst parameters whose mean value is minimal and by which the delay requirements of hard real-time connections can be met. The exponential size of the search space makes this problem a challenging one. The algorithm is efficient through systematically pruning the search space. There is an observed dramatic improvement in the system performance in terms of the connection admission probability when traffic is regulated using this algorithm.
2261294
Predicting the Upper Bound of Web Traffic Volume Using a Multiple Time Scale Approach
This paper presents a prediction algorithm for estimating the upper bound of future Web traffic volume. Unlike traditional traffic predictions that are performed at a single time scale using curve fitting, we employ a multiple time scale approach and utilize traffic statistical properties to do forecasting. We have applied our prediction algorithm to the 1998 World Cup data set. Experiments show that it is effective for short term traffic bound predictions, applicable to bursty traffic, and useful for Web server overload prevention.
9589474
DotSlash: A Self-Configuring and Scalable Rescue System for Handling Web Hotspots Effectively
DotSlash allows different web sites to form a mutual-aid community, and use spare capacity in the community to relieve web hotspots experienced by any individual site. As a rescue system, DotSlash intervenes when a web site becomes heavily loaded, and is phased out once the workload returns to normal. It aims to complement the existing web server infrastructure to handle short-term load spikes effectively. DotSlash is self-configuring, scalable, cost-effective, easy to use, and transparent to clients. It targets small web sites, although large web sites can also benefit from it. We have implemented a prototype of DotSlash on top of Apache. Experiments show that using DotSlash a web server can increase the request rate it supported and the data rate it delivered to clients by an order of magnitude, even if only HTTP redirect is used. Parts of this work may be applicable to other services such as Grid computational services.
12365152
A multi-access window protocol for transmission of time constrained messages
A novel window protocol for transmitting time-constrained messages in a multiaccess network is proposed that explicitly takes time constraints into account. The window is formed on the basis of latest time to send a message (LS). A newly arriving message is immediately considered for transmission if its LS is less than those of the all pending messages in the system. As a result, the protocol closely approximates the optimal minimum-laxity-first policy. A performance evaluation by simulation shows that the protocol performs well in a wide range of environments, even under overloaded conditions.<<ETX>>