A three-tier application is organized as three layers. Front end clients (e.g., browsers) with which human user interact; middle-tier servers (e.g., web servers) that contain the core business logic of the application; and back-end database servers against which application servers perform transactions. Although three-tier applications are nowadays mainstream, they usually fail to provide sufficient reliability guarantees to the end users. Usually, ad-hoc replication and transactional techniques are developed for specific parts of the application, but these techniques are not combined to provide some global notion of reliability. The aim of this paper is precisely to define a desirable, yet realistic, specification of end-toend reliability in three-tier applications. We present the specification in the form of a problem called Transactional Exactly-Once which encompasses both safety and liveness properties in such environments. We also describe a practical protocol that solve...

Abstract. Distributed transactional systems require an atomic commitment protocol to preserve atomicity of the ACID properties. However, the industry leading standard, 2PC, is slow and adds a significant overhead to transaction processing. In this paper, a new atomic commitment protocol for main-memory primarybackup systems, C2PC, is proposed. It exploits replication to avoid disk-logging and performs the commit processing in a circular fashion. The analysis shows that C2PC has the same delay as 1PC, and reduces the total overhead compared to 2PC. 1

Abstract. This paper describes, for the case of Enterprise Java Bean components and JBoss application server, how replication for availability can be supported to tolerate application server/transaction manager failures. Replicating the state associated with the progression of a transaction (i.e., which phase of two-phase commit is enacted and the transactional resources involved) provides an opportunity to continue a transaction using a backup transaction manager if the transaction manager of the primary fails. Existing application servers do not support this functionality. The paper discusses the techical issues involved and shows how a solution can be engineered.

Abstract. Replication is crucial to achieve high availability distributed systems. However, non-determinism introduces consistency problems between replicas. Transactions are very well suited to maintain consistency, and by integrating them with replication, support for non-deterministic execution in replicated environments can be achieved. This paper presents an approach where a passively replicated transaction manager is allowed to break replication transparency to abort orphan requests, thus handling non-determinism. A prototype implemented using existing open-source software, Jgroup/ARM and Jini, has been developed, and performance and failover tests have been executed. The results show that while this approach is possible, components specifically tuned for performance must be used to meet real-time requirements.

Atomic commit protocols are used where data integrity is more important than data availability. Two-Phase commit (2PC) is a standard commit protocol for commercial database management systems. To reduce certain drawbacks in 2PC protocol people have suggested different variance of this protocol. Short-Commit protocol is developed with an objective to achieve low cost transaction commitment cost with nonblocking capability. In this paper we have briefly explained short-commit protocol executing pattern. Experimental analysis and results are presented to support the claim that short-commit can work efficiently in extreme database environment. Commit Protocol ensures the transaction atomicity. To understand the role of commit protocols we consider an example of funds transfer from one account to another. We consider a transaction that transfers funds from account A to account B. This transaction consists of two sub transactions, one sub transaction debit sum A and second sub

Abstract—Three-tier middleware architecture is commonly used for hosting enterprise-distributed applications. Typically, the application is decomposed into three layers: front end, middle tier, and back end. Front end (“Web server”) is responsible for handling user interactions and acts as a client of the middle tier, while back end provides storage facilities for applications. Middle tier (“Application server”) is usually the place where all computations are performed. One of the benefits of this architecture is that it allows flexible management of a cluster of computers for performance and scalability; further, availability measures, such as replication, can be introduced in each tier in an application-specific manner. However, incorporation of availability measures in a multitier system poses challenging system design problems of integrating open, nonproprietary solutions to transparent failover, exactly once execution of client requests, nonblocking transaction processing, and an ability to work with clusters. This paper describes how replication for availability can be incorporated within the middle and back-end tiers, meeting all these challenges. This paper develops an approach that requires enhancements to the middle tier only for supporting replication of both the middleware back-end tiers. The design, implementation, and performance evaluation of such a middle-tier-based replication scheme for multidatabase transactions on a widely deployed open source application server (JBoss) are presented.