PDF de programación - Técnicas de desarrollo de aplicaciones distribuidas tolerantes a fallos sobre arquitecturas CORBA y JAVARMI

TÉCNICAS DE DESARROLLO DE APLICACIONES
DISTRIBUIDAS TOLERANTES A FALLOS SOBRE

ARQUITECTURAS CORBA Y JAVARMI

Memoria que presenta para optar al grado de

Doctor en Informática

Luis Miguel Peña Cabañas

Dirigida por el doctor

Juan Pavón Mestras

Departamento de Sistemas Informáticos y Programación

Facultad de Informática

Universidad Complutense de Madrid

Febrero, 2002

Si lo puedes soñar, lo puedes hacer.

- Walt Disney

One ring to rule them all,

One ring to find them,

One ring to bring them all

and in the Darkness bind them

- J. R. R. Tolkien

(ejemplo de diseño centralizado,

no tolerante a fallos)

A todos los que os he conocido durante estos largos años de doctorado. Lo largo ha
hecho, al menos, que seáis muchos. Gracias por vuestra compañía y apoyo. A todos

los sitios donde he vivido y disfrutado mientras Sensei iba evolucionando. En especial,
por los recuerdos que me traen en relación con esta Tesis, Brujas, Amberes, Dublin, y

un trayecto Frankfurt-Stuttgart tantas veces recorrido.

iii

iv

Resumen

Las técnicas de tolerancia a fallos en arquitecturas distribuidas cliente/servidor
(como CORBA, Java RMI o Microsoft DCOM), que a nivel software se implementan
principalmente mediante la replicación de servidores para ocultar fallos individuales,
presentan una interfaz de muy bajo nivel que hacen difícil la implementación de los
servicios tolerantes a fallos. El rendimiento de estos sistemas, que deben actualizar
en cada operación dos o más servidores en lugar de sólo uno, y cuya actualización
debe realizarse con una sincronización muy cuidada para evitar inconsistencias, es
sensiblemente inferior al de los sistemas no tolerantes a fallos. Por esta razón, las
principales líneas de investigación en esta área han buscado las formas de optimizar
esas comunicaciones para obtener sistemas con un rendimiento práctico.

Sin embargo, otras líneas de investigación se han centrado en el estudio de patrones
de implementación que faciliten el empleo de las técnicas subyacentes de tolerancia
a fallos. El sistema propuesto en esta tesis, Sensei, se encuentra en este campo,
estudiando cómo aplicar estas técnicas a grupos de objetos y cómo definir una
interfaz de alto nivel que permita un cómodo empleo de los modelos de
comunicaciones fiables entre servidores replicados.

Por una parte, Sensei trata el problema de la transferencia de estado entre réplicas,
un aspecto de la replicación cubierto en la teoría básica de sincronía virtual pero con
muy poca cobertura en las implementaciones actuales. Definimos un modelo que
cubre desde los protocolos de bajo nivel especificando los mensajes y los
rendimientos en diversos sistemas, hasta los protocolos de alto nivel especificando
su interfaz en lenguaje IDL de CORBA. Más importante, estudiamos las condiciones
que deben cumplir las aplicaciones para poder emplear los distintos modelos de
transferencia de estado y cómo afectan al modelo de sincronía virtual sobre el que se
construyen las aplicaciones replicadas.

Estos protocolos se implementan parcialmente sobre uno de los sistemas de
comunicaciones fiables más conocidos, Ensemble. No obstante, hemos desarrollado
también un sistema de comunicaciones fiables propio, SenseiGMS, persiguiendo
definir una interfaz general, común a los modelos actualmente existentes, sobre la
que implementamos totalmente los protocolos desarrollados.

Una vez resuelta la transferencia de estado, Sensei se centra en los patrones de
comunicación de alto nivel, que permiten a aplicaciones orientadas a objetos
mantenerse en el mismo nivel de abstracción al replicar esos objetos. El sistema
tradicional de comunicaciones en los sistemas de comunicaciones fiables entre
réplicas es el intercambio de mensajes entre esas réplicas, mientras que en Sensei
hemos desarrollado una aplicación, SenseiDomains, que permite factorizar esas
comunicaciones a nivel de componentes que pueden definirse dinámicamente en
dominios, buscándose de esta manera la abstracción de objetos.

v

Además, se observan los patrones más empleados al diseñar las aplicaciones con
tolerancia a fallos, implementándolos o soportándolos en la medida de lo posible.
Una aplicación directa de este soporte de los patrones de implementación es la
posibilidad de replicar automáticamente aplicaciones diseñadas inicialmente como
entidades autónomas sin replicación. Sensei define la forma de migrar esas
aplicaciones para soportar tolerancia a fallos y formas posteriores de optimizar las
comunicaciones entre las réplicas resultantes. Para soportarlo se ha desarrollado la
herramienta SenseiUMA.

Como ejemplo de aplicación de la metodología propuesta, se muestra el diseño de
otra de las piezas de la arquitectura, SenseiGMNS, servicio de gestión de grupos
cuyos componentes están replicados, a su vez, sobre Sensei.

Palabras clave

Sistemas distribuidos, CORBA, JavaRMI, Tolerancia a Fallos, Replicación de
Objetos, Transferencia de Estado, Comunicaciones en grupo.

vi

Summary

Fault Tolerance software techniques for distributed client/server architectures (like
CORBA, JavaRMI or Microsoft DCOM) are usually based on the replication of the
servers to hide single failures. However, these techniques work at a low level, making
difficult the implementation of fault tolerant services. These systems must update on
each request two or more servers instead of just one, and the multiple updates must
be carefully synchronized to avoid inconsistencies. As a result, the performance on
those systems is considerably worse than the equivalent non fault tolerant case. This
is the reason why the main research efforts on this area have been focused on the
optimization of the communications between replicas to obtain systems with a
practical performance.

Nevertheless, other line of work has taken a different approach, focusing on the
implementation patterns that facilitate the use of the fault tolerant techniques. The
system proposed in this Thesis, Sensei, belongs to this second area, studying the
application of those techniques to groups of objects and the definition of a high level
interface to facilitate the use of the reliable communication models.

On one side, Sensei addresses the problem of the state transfer between replicas, an
aspect of the replication that, despite being covered by the virtual synchrony model,
has usually a poor coverage on current implementations of this model. We define a
model to solve this issue, which addresses low level protocols, specifying the
messages and the performance on a variety of systems, and high level protocols,
defining their interface on CORBA IDL. What is more important, we study the
conditions that the applications must hold in order to use the different state transfer
models, and how do they affect to the virtual synchrony model.

These protocols are partially implemented on top of one well-known group
communication system, Ensemble. Nevertheless, we have developed as well our own
reliable group communication system, SenseiGMS, with a generic interface, common
to the existing ones, and the protocols are completely implemented over it.

Once the state transfer issue is solved, Sensei
focuses on the communication
patterns that happen at high level, which allow object-oriented applications to keep
on the same abstraction level when those objects are replicated. The basic traditional
communication entity on reliable group systems is the message, and replicas must
communicate among themselves using this low level mechanism. In Sensei, we have
developed an application, SenseiDomains, that factorizes those communications into
component interactions, components that can be dynamically defined, offering a
standard object orientation abstraction.

Additionally, we have studied the design process of
fault tolerant applications,
catching the most usual implementation patterns, in order to implement or support
them. A direct benefit of this support is the possibility to automatically replicate
applications that have been initially designed as standalone. Sensei defines how to

vii

migrate those applications to have fault tolerance, and how to optimize afterwards
the communications between the created replicas. SenseiUMA is the tool designed to
support this migration.

the proposed methodology, we

As an example of
show the design and
implementation of one of the architectural elements in Sensei, called SenseiGMNS.
This is a group membership service that is itself replicated following the design
principles and with the support of SenseiDomains.

Keywords

Distributed systems, CORBA, JavaRMI, Fault Tolerance, Object Replication, State
Transfer, Group Communications.

viii

ÍNDICE

CAPÍTULO 1 - INTRODUCCIÓN.......................................................................................... 1

CAPÍTULO 2 - SISTEMAS DISTRIBUIDOS ........................................................................ 7

2.1. MODELOS DISTRIBUIDOS................................................................................................... 8
2.2. SOCKETS .......................................................................................................................... 9
2.3. RPC – LLAMADAS A PROCEDIMIENTOS REMOTOS............................................................ 10
2.4. OBJETOS DISTRIBUIDOS................................................................................................... 11
2.5. TENDENCIAS ACTUALES.................................................................................................. 14
2.6. CONCLUSIONES............................................................................................................... 15

CAPÍTULO 3 - SISTEMAS DISTRIBUIDOS FIABLES..................................................... 17

3.1. FIABILIDAD..................................................................................................................... 17
3.1.1. Tolerancia a fallos ..................................................................