Summary There are two main approaches to manage changes in XML documents, change‐tracking and diff. Change‐tracking tools, which record edit actions while they are performed on the source document, are able to capture the exact editing process. That is much more difficult for diff algorithms, which have to reconstruct it by comparing two different versions. Interestingly, these algorithms process both text‐centric and data‐centric XML documents the same way. In this paper, we show that more accurate, clear, and human‐readable results can be achieved on text‐centric resources, by employing specific models and algorithms. We describe and discuss a specialized diff algorithm for such a class of documents. We also compare a Java implementation of the algorithm, named JNDiff, with other general‐purpose or data‐oriented diff tools, focusing on the quality of their output. Copyright © 2014 Copyright © 2014 John Wiley & Sons, Ltd.

Keeping strongly consistent the state of the replicas of a software service deployed across a distributed system prone to crashes and with highly unstable message transfer delays (e.g., the Internet), is a real practical challenge. The solution to this problem is subject to the FLP impossibility result, and thus there is a need for "long enough" periods of synchrony with time bounds on process speeds and message transfer delays to ensure deterministic termination of any run of agreement protocols executed by replicas. This behavior can be abstracted by a partially synchronous computational model. In this setting, before reaching a period of synchrony, the underlying network can arbitrarily delay messages and these delays can be perceived as false failures by some timeout-based failure detection mechanism leading to unexpected service unavailability. This paper proposes a fully distributed solution for active software replication based on a three-tier software architecture well-suited to such a difficult setting. The formal correctness of the solution is proved by assuming the middle-tier runs in a partially synchronous distributed system. This architecture separates the ordering of the requests coming from clients, executed by the middle-tier, from their actual execution, done by replicas, i.e., the end-tier. In this way, clients can show up in any part of the distributed system and replica placement is simplified, since only the middle-tier has to be deployed on a well-behaving part of the distributed system that frequently respects synchrony bounds. This deployment permits a rapid timeout tuning reducing thus unexpected service unavailability.

This paper introduces a novel architecture for implementing content-based pub/sub communications on top of structured overlay networks. This architecture overcomes some well-known limitations of existing infrastructures, i.e. lack of self-configuration and of adaptiveness to dynamic changes. This is achieved by devising a mediator stratum between the rich event subscription semantics of content-based pub/sub systems and the standard logical addressing scheme of overlays. The paper describes details of the design and provides considerations in selecting the subscription-to-node and event-to-node mappings suitable for the solution. We identify the lack of native support for one-to-many communication by overlay networks as the main impediment for efficient system operation. The paper introduces a novel primitive for one-to-many message delivery, showing through simulation how this can improve performance of the architecture. The simulation study also shows performance comparison between the different mappings proposed as well as evaluation of other optimizations discussed in the paper

Cooperative information systems (CISs) are often characterized by a high degree of data replication; as an example, in an e-government scenario, the personal data of citizens are stored by almost all administrations. In such scenarios, organizations typically provide the same information with distinct quality levels and this enables providing users with data of the highest available quality. Furthermore, the comparison of data values might be used to enforce a general improvement of data quality in all organizations. In the DaQuinCIS project (Aguilera et al., 1999), we propose an architecture for the management of data quality in CISs; this architecture allows the diffusion of data and related quality and exploits data replication to improve the overall quality of cooperative data. In this paper, we present an overview of a component of the DaQuinCIS architecture, namely the quality notification service (QNS), which is used to inform interested users when changes in quality values occur within the CIS. QNS can be used to control the quality of critical data, e.g. to keep track of quality changes and to be always aware when quality degrades under a certain threshold. The interaction between the QNS and its users follows the publish/subscribe paradigm: a user willing to be notified for quality changes subscribes to the QNS by submitting the features of the events to be notified for, through a specific subscription language. When a change in quality occurs, an event is published by the QNS i.e., all the users which have a consistent subscription receive a notification. However, as shown in the paper by Marchetti et al. (2003), currently available pub/sub infrastructures do not allow to meet all the requirements that a QNS implementation should satisfy, in particular scaling to a large number of users and coping with platform heterogeneity. QNS addresses both these problems through a layered architecture that: (i) encapsulates the technological infrastructure specific of each organization; (ii) adopts the standard Web-service technology to implement inter-organization communications; and (iii) embeds solutions and algorithms (namely, merge subscriptions and diffusion trees) to reduce the use of physical and computational resources. The remainder of this paper is organized as follows: we first introduce some preliminary concepts and the QNS specification; then we motivate and describe the internal architecture of the service. Due to the lack of space, explanations are given at a very high abstraction level. Interested readers can find technical and formal details, as well as running examples, in the paper by Scannapieco et al. (2003).

Abstract 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 achievedwithout modifyingeither 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.

Abstract Enforcing strong replica consistency among a set of replicas of a service deployed across anasynchronousdistributed system in the presence of crash failures is a real practical challenge. If each replica runs the consistency protocol bundled with the actual service implementation, this target cannot be achieved, as replicas need to be located over apartially synchronous distributed systemto solve the distributed agreement problems underlying strong replica consistency. A three‐tier architecture for software replication enables the separation of the replication logic, i.e. protocols and mechanisms necessary for managing software replication, from both clients and server replicas. The replication logic is embedded in a middle‐tier that confines the need of partial synchrony and thus frees replica deployment. In this paper we first introduce the basic concepts underlying three‐tier replication. Then we present the interoperable replication logic (IRL) architecture, a fault‐tolerant CORBA compliant infrastructure. IRL exploits a three‐tier approach to replicate stateful deterministic CORBA objects and allows object replicas to run on object request brokers from different vendors. A description of an IRL prototype developed in our department is proposed along with an extensive performance analysis. Copyright © 2003 John Wiley & Sons, Ltd.

The deployment of server replicas of a service across an asynchronous distributed system (e.g., Internet) is a real practical challenge. This target cannot be indeed achieved by classical software replication techniques (e.g., passive and active replication) as these techniques usually rely on group communication toolkits that require server replicas to run over a partially synchronous distributed system to solve the underlying agreement problem. This paper proposes a three-tier architecture for software replication that encapsulates the need of partial synchrony in a specific software component of a mid-tier to free replicas and clients from the need of underlying partial synchrony assumptions. Then we propose how to specialize the mid-tier in order to manage active replication of server replicas.

A replication logic is the set of protocols and mechanisms implementing a software replication technique. A three-tier approach to replication consists in separating the replication logic from both clients and replicated servers by embedding such logic in a middle-tier In this paper we first introduce the fundamental concepts underlying three-tier replication. This approach has two main practical advantages: (i) it allows to maintain consistency among the state of server replicas deployed within an asynchronous distributed system and (ii) it supports very thin clients. Then we present the Interoperable Replication Logic (IRL) architecture, which is a Fault Tolerant CORBA compliant infrastructure exploiting a three-tier approach to replicate stateful deterministic CORBA objects. In this context, we illustrate the three-tier replication protocol currently implemented in our IRL prototype and a performance analysis that shows the feasibility of the three-tier approach to software replication.

Integrating autonomous enterprise systems allows the cooperation among applications belonging to distinct systems. As an example, this problem shows up when integrating software services of large departments and organizations in e-government initiatives. This paper studies, in the context of the Unitary Network of the Italian Public Administration, the problem of increasing the availability of services exported by an autonomous enterprise system towards others. In particular we show how a fault tolerant CORBA system, namely the Interoperable Replication Logic (IRL), can be used to increase such an availability by building a replicated cooperative gateway that wraps enterprise applications.

We investigate issues related to building highly available World Wide Web (WWW) servers on workstation clusters. We present a novel architecture that includes a dynamic Domain Name System (DNS) and a WWW server based on passive object replication. This architecture allows us to reduce the service down-time of a WWW server without impacting on the Hyper Text Transfer Protocol (HTTP) protocol (and thus on the WWW client software). We implement this architecture in our department and we show some experimental results that analyze, given a batch of HTTP requests, the average response time to a request and the average time of WWW service unavailability due to object crashes.