Título: Herramienta administrativa para mecanismo de ...

I

Universidad Central “Marta Abreu” de las Villas Facultad de Matemática Física y Computación

Departamento de Ciencia de la Computación

Título: Herramienta administrativa para mecanismo de replicación SymmetricDS

Tesis Presentada en Opción al Título Académico de Máster en Ciencia de la Computación

Autor:

Ing. Reinier Castillo Figueroa

Tutor:

Dr. Rosendo Moreno Rodríguez

Santa Clara 2011

El futuro tiene muchos nombres. Para los débiles es lo

inalcanzable. Para los temerosos, lo desconocido. Para los

valientes es la oportunidad.

Víctor Hugo

RESUMEN

I

RESUMEN

La carencia de herramientas gráficas y libres para la replicación entre bases de datos,

entorpecen el desarrollo y rapidez en la instalación y configuración de los mecanismos de

réplica. Es por ello que la presente investigación aborda el diseño e implementación de una

herramienta libre, que funcione sobre la web 2.0 y administre con eficiencia todos los

objetos del mecanismo de replicación SymmetricDS. Para ello, se parte de los conceptos

asociados a la replicación de datos y del estudio y caracterización de los mecanismos de

réplica de software libre más utilizados destacándose las ventajas de SymmetricDS.

Además se fundamentan las tecnologías y herramientas de software libre que serán

utilizadas en la implementación de la interfaz de administración. Se describen los Casos de

Uso del sistema, diagramas de clase y de componentes más significativos. También se

detalla el diagrama de despliegue que servirá de apoyo para la implantación del sistema.

Finalmente y con el objetivo de facilitar la interacción de los usuarios con la herramienta,

se realiza una descripción de las funcionalidades de la misma a través del manual de

usuario.

ABSTRACT

II

ABSTRACT

The lack of graphics and free tools for replication between databases, hinder the

development and speed of installation and configuration of replication mechanisms. That is

why this research comes about the design and implementation of a free tool that works on

web 2.0 and efficiently manages all objects in the replication mechanism SymmetricDS. It

starts with the concepts associated with data replication and the study and characterization

of free software replication mechanisms most widely used highlighting the advantages of

SymmetricDS. In addition, it´s also fundamented the technologies and free software tools

to be used in the implementation of the management interface. We describe the system use

cases, class diagrams and most significant components. It also detailed the deployment

diagram which will support the implementation of the system. Finally, with the aim of

facilitating the user interaction with the tool, there is a description of the features of it

through the user manual.

TABLA DE CONTENIDOS

III

TABLA DE CONTENIDOS

INTRODUCCIÓN -------------------------------------------------------------------------------------------------- 1

CAPÍTULO I: Mecanismos de replicación de datos en SGBD ---------------------------------------- 6

1.1 Conceptos generales ---------------------------------------------------------------------------------------6

1.1.1 Replicación ---------------------------------------------------------------------------------------------------------- 6

1.1.2 Replicación multimaster ------------------------------------------------------------------------------------------ 6

1.1.3 Propagación sincrónica ------------------------------------------------------------------------------------------- 7

1.1.4 Replicación heterogénea ----------------------------------------------------------------------------------------- 7

1.1.1 Replicación lógica ------------------------------------------------------------------------------------------------- 7

1.2 SymmetricDS como mecanismo de replicación de datos libre ----------------------------------7

1.2.1. Slony I ------------------------------------------------------------------------------------------------------------ 8

1.2.2. CyberCluster ---------------------------------------------------------------------------------------------------- 8

1.2.3. PgCluster --------------------------------------------------------------------------------------------------------- 9

1.2.4. Pyreply------------------------------------------------------------------------------------------------------------ 9

1.2.5. Streaming replication ---------------------------------------------------------------------------------------- 10

1.2.6. DBReplicator -------------------------------------------------------------------------------------------------- 10

1.2.7. SymmetricDS ------------------------------------------------------------------------------------------------- 10

1.3 Ambiente de desarrollo de la aplicación ----------------------------------------------------------- 13

1.3.1 Tecnologías ------------------------------------------------------------------------------------------------------- 13

1.3.1.1 Lenguaje de programación del lado del servidor --------------------------------------------------- 13

1.3.1.1.1 Python --------------------------------------------------------------------------------------------------- 13

1.3.1.1.2 Java ------------------------------------------------------------------------------------------------------ 15

1.3.1.2 Lenguaje de programación del lado del cliente----------------------------------------------------- 17

1.3.1.2.1 HTML --------------------------------------------------------------------------------------------------- 18

1.3.1.2.2 Java Script ---------------------------------------------------------------------------------------------- 18

1.3.1.2.3 CSS ------------------------------------------------------------------------------------------------------ 19

1.3.1.3 Servidores -------------------------------------------------------------------------------------------------- 19

1.3.1.3.1 Apache -------------------------------------------------------------------------------------------------- 19

1.3.1.3.2 Tomcat -------------------------------------------------------------------------------------------------- 20

1.3.1.3.2.1. Axis2 ---------------------------------------------------------------------------------------------- 21

1.3.2 Frameworks de desarrollo ------------------------------------------------------------------------------------- 21

1.3.2.1 Django------------------------------------------------------------------------------------------------------- 21

1.3.2.2 Hibernate --------------------------------------------------------------------------------------------------- 22

1.3.3 Bibliotecas --------------------------------------------------------------------------------------------------------- 23

1.3.3.1 ExtJS--------------------------------------------------------------------------------------------------------- 23

1.3.3.2 Suds ---------------------------------------------------------------------------------------------------------- 24

1.3.4 Herramientas ------------------------------------------------------------------------------------------------------ 24

1.3.4.1 Visual Paradigm------------------------------------------------------------------------------------------- 24

1.3.4.2 Eclipse------------------------------------------------------------------------------------------------------- 25

1.4 Conclusiones del capítulo ------------------------------------------------------------------------------ 26

TABLA DE CONTENIDOS

IV

CAPÍTULO II: Modelado de la interfaz de administración para SymmetricDS --------------- 27

2.1. SymmetricDS ---------------------------------------------------------------------------------------------- 27

2.2. Arquitectura del sistema ------------------------------------------------------------------------------- 29

2.3. Componentes de la Herramienta -------------------------------------------------------------------- 31

2.4. Casos de uso del sistema -------------------------------------------------------------------------------- 33

2.5. Diagramas de clases -------------------------------------------------------------------------------------- 43

2.5.1. Diagrama de clases de la aplicación en Django (Python) -------------------------------------------- 44

2.5.2. Diagrama de clases del servicio web --------------------------------------------------------------------- 46

2.6. Diagramas de secuencias ------------------------------------------------------------------------------- 49

2.7. Diseño de la base de dato ------------------------------------------------------------------------------- 53

2.8. Conclusiones del capítulo ------------------------------------------------------------------------------ 56

CAPÍTULO III: Implementación y manual de usuario ------------------------------------------------ 57

3.1. Implementación ------------------------------------------------------------------------------------------- 57

3.1.1. Diagrama de Componentes --------------------------------------------------------------------------------- 57

3.1.2. Paquetes de las aplicaciones ------------------------------------------------------------------------------- 60

3.1.3. Diagrama de Despliegue ------------------------------------------------------------------------------------ 61

3.2. Manual de Usuario --------------------------------------------------------------------------------------- 62

3.2.1. Estructura de la interfaz principal ------------------------------------------------------------------------- 63

3.2.1.1. Componentes ---------------------------------------------------------------------------------------------- 63

3.2.1.2. Área de trabajo -------------------------------------------------------------------------------------------- 66

3.2.2. Interfaces de usuario de los componentes --------------------------------------------------------------- 68

3.2.2.1. Interfaces de usuario para los sets. -------------------------------------------------------------------- 69

3.2.2.2. Interfaces de usuario para los servicios. ------------------------------------------------------------- 70

3.2.2.3. Interfaces de usuario para los grupos. ---------------------------------------------------------------- 71

3.2.2.4. Interfaces de usuario para los nodos. ----------------------------------------------------------------- 72

3.2.2.5. Interfaces de usuario para los vínculos entre grupos. --------------------------------------------- 75

3.2.2.6. Interfaces de usuario para los canales. --------------------------------------------------------------- 77

3.2.2.7. Interfaces de usuario para los disparadores. --------------------------------------------------------- 78

3.2.2.8. Interfaces de usuario para los ruters.------------------------------------------------------------------ 80

3.2.2.9. Interfaces de usuario para los ruters - disparadores. ----------------------------------------------- 81

3.2.3. Visualización de datos: -------------------------------------------------------------------------------------- 83

3.3. Conclusiones del capítulo ------------------------------------------------------------------------------ 84

CONCLUSIONES ------------------------------------------------------------------------------------------------ 85

RECOMENDACIONES ----------------------------------------------------------------------------------------- 86

REFERENCIAS BIBLIOGRÁFICAS ---------------------------------------------------------------------------- 87

BIBLIOGRAFÍA -------------------------------------------------------------------------------------------------- 88

ÍNDICE DE FIGURAS

V

ÍNDICE DE FIGURAS

FIGURA 1: Diagrama de integración de tecnologías .................................................................... 30

FIGURA 2: Diagrama de interacción ente las aplicaciones de la herramienta................................ 31

FIGURA 3: Diagrama de casos de uso del sistema ....................................................................... 33

FIGURA 4: Diagrama de clases de la aplicación web ................................................................... 44

FIGURA 5: Diagrama de clases del servicio web ......................................................................... 47

FIGURA 6: Diagrama de secuencia para el caso de uso crear nodo............................................... 50

FIGURA 7: Diagrama de secuencia para el caso de uso eliminar nodo ......................................... 51

FIGURA 8: Modelo físico de datos de la aplicación web .............................................................. 54

FIGURA 9: Modelo físico de las tablas de metadato del mecanismo SymmetricDS ...................... 55

FIGURA 10: Diagrama de componentes para el caso de uso gestionar nodo ................................. 58

FIGURA 11: Componentes del paquete servicio web implicados en el caso de uso gestionar nodo 60

FIGURA 12: Diagrama de despliegue de la herramienta ............................................................... 61

FIGURA 13: Interfaz principal de la aplicación. ........................................................................... 63

FIGURA 14: Árbol de componentes en el explorador. ................................................................. 64

FIGURA 15: Clic derecho para la opción de editar y eliminar componentes. ................................ 65

FIGURA 16: Clic derecho para la opción de crear componentes. ................................................. 66

FIGURA 17: Submenú set replicación. ........................................................................................ 67

FIGURA 18: Submenú servicio de administración. ...................................................................... 67

FIGURA 19: Submenú nodos....................................................................................................... 68

FIGURA 20: Submenú disparadores............................................................................................ 68

FIGURA 21: Interfaz de usuario crear set de replicación. ............................................................ 69

FIGURA 22: Interfaz de usuario crear servicio de administración................................................ 70

FIGURA 23: Interfaz de usuario crear grupo de replicación. ....................................................... 71

FIGURA 24: Interfaz de usuario crear nodo. ................................................................................ 73

FIGURA 25: Interfaz de usuario nodos. ....................................................................................... 74

FIGURA 26: Interfaz de usuario crear vínculo entre grupos. ........................................................ 76

FIGURA 27: Interfaz de usuario crear canal de replicación. ........................................................ 77

FIGURA 28: Interfaz de usuario crear disparador. ...................................................................... 79

FIGURA 29: Interfaz de usuario crear ruter. ................................................................................ 80

FIGURA 30: Interfaz de usuario crear ruter - disparador. ........................................................... 82

FIGURA 31: Interfaz de usuario de la vista de datos. ................................................................... 83

ÍNDICE DE TABLAS

VI

ÍNDICE DE TABLAS

TABLA 1: Variables de la hipótesis de investigación ..................................................................... 3

TABLA 2: Comparación ente mecanismos de replicación libres para PostgreSQL ........................ 11

TABLA 4: Descripción del caso de uso crear nodo ....................................................................... 34

TABLA 5: Descripción del caso de uso eliminar nodo.................................................................. 38

TABLA 6: Descripción del caso de uso modificar nodo ............................................................... 40

INTRODUCCIÓN

1

INTRODUCCIÓN

Con el surgimiento de los Sistemas Gestores de Base Datos (SGBD) se ha logrado un

avance significativo para el almacenamiento de la información. La posibilidad de compartir

datos, eliminar inconsistencias, mejorar la seguridad; y como valor agregado, recolectar

cualquier tipo de información, ahorrar espacio de almacenamiento, y replicar datos ha

convertido a los SGBD en la principal fuente de almacenamiento en el campo informático.

Una de las funcionalidades que más se tiene en cuenta al usar un servidor de base datos con

fines productivos, es la capacidad de replicar sus datos hacia diferentes SGBD, permitiendo

la transferencia automática de los mismos de un lugar a otro, con la seguridad requerida.

La mayoría de los SGBD de una forma u otra emplean algún mecanismo de replicación.

Los gestores privativos poseen mecanismos intuitivos y fáciles de usar, pero requiere el

pago de una cuota periódica por su licencia, mientras que los libres carecen de herramientas

administrativas que faciliten el trabajo con el mecanismo de replicación.

Si se desea solucionar un problema informático de replicación de datos haciendo uso de un

gestor privativo, aparecen dos variantes muy usadas, SQLSERVER (Microsoft

Corporation 2011) y ORACLE (Oracle Corporation 2011). Las dos opciones poseen las

herramientas necesarias para montar una solución de réplica a la magnitud que se desee

implantar, aunque hay tener en cuenta que para su uso se deben invertir grandes sumas de

dinero en pago de licencias se software.

Otra limitación del modelo software privativo es que generalmente hace cumplir las

restricciones que cuando por razón de que su gobierno mantiene algún tipo de sanción

económica para con el país del que es ciudadano o residente el interesado. Ejemplo típico

en este sentido es la imposibilidad de adquisición de software propietario norteamericano

por parte de Cuba (Batista Soler, O., & Rodríguez Figueredo, H 2006). Es significativo que

las grandes empresas desarrolladoras de software tienen su domicilio legal en Estados

Unidos.

INTRODUCCIÓN

2

Por tales motivos el Estado cubano ha encaminado sus esfuerzos a la informatización de la

sociedad basados en la aplicación ordenada y masiva de las Tecnologías de la Información

y las Comunicaciones y orientado a lograr la soberanía tecnológica.

Dentro de los SGBD libres, PostgreSQL (PostgreSQL Global Development Group 1996)

posee diferentes mecanismos de replicación de datos como SLONY (Slony Development

Group 2007), PYREPLY (Mariano Reingart 2009), entre otros; pero la instalación y

administración de estos mecanismos resulta bastante difícil, dado que carecen de interfaces

gráficas para su configuración. Esta característica dificulta el uso de los mecanismo libres

quedando disponible estas soluciones solo para usuarios avanzados en el tema y obligando

a los principiantes a usar soluciones privativas.

SymmetricDS (JumpMind, Inc 2007) es una solución libre para la replicación de base datos

entre diferentes gestores. La característica que lo hace más atractivo es la capacidad de

replicar datos entre redes WAN1 si necesidad del montaje de sistemas VPN

2 en las redes

origen y destino; sin embargo no contar con una interfaz de usuario que lo administre,

ocasiona el rechazo de los usuarios. Esta deficiencia de SymmetricDS no permite explotar

al máximo todas sus potencialidades, limitando con ello la calidad de las soluciones

informáticas en que se aplique.

De la situación problemática anterior se plantea el siguiente problema científico: la

carencia de herramientas gráficas libres para la administración del mecanismo de

replicación SymmetricDS, obstaculizan su uso para solucionar problemas de replicación

en bases de datos.

El objeto de estudio del problema se enmarca en las herramientas administrativas para la

replicación de bases de datos y el campo de acción en las herramientas administrativas

para el mecanismo de replicación SymmetricDS.

1 WAN: tipo de red de computadoras capaz de cubrir distancias desde unos 100km hasta unos 1000 km, dando el

servicio a un país o un continente. 2 Virtual Private Network (VPN): es un sistema para simular una red privada sobre una red pública.

INTRODUCCIÓN

3

Para dar solución al problema científico se plantea como objetivo general: elaborar una

herramienta con interfaces gráficas, sobre la web 2.0, que facilite a los usuarios la

configuración y administración del mecanismo de replicación SymmetricDS.

Como objetivos específicos se plantea:

1. Caracterizar el mecanismo de replicación SymmetricDS.

2. Definir las tecnologías de software libre apropiadas para crear una aplicación que

permita administrar SymmetricDS orientado a la web 2.0.

3. Desarrollar el análisis y diseño de la herramienta con la ayuda del UML.

4. Implementar una herramienta administrativa para el mecanismo de replicación

SymmetricDS sobre la web 2.0.

Se define como hipótesis de investigación: si se crea una herramienta con interfaces

gráficas para administrar el mecanismo de replicación SymmetricDS, entonces se

incrementará su usabilidad por parte de los administradores de bases de datos que

necesiten replicar información entre gestores que estén soportados por la herramienta.

Variables

Tabla 1: Variables de la hipótesis de investigación

Independientes Dependientes

Herramienta con interfaces

gráficas, para administrar el

mecanismo de replicación

SymmetricDS

Usabilidad del mecanismo por parte de los

administradores de bases de datos que

necesiten replicar información entre gestores

que estén soportados por la herramienta

El tipo de investigación utilizado es la investigación descriptiva aplicando los métodos de

investigación: histórico lógico, analítico sintético e hipotético deductivo.

INTRODUCCIÓN

4

Justificación de la investigación

Con el avance de las tecnologías, los SGBD son cada día más usados y con ellos los

mecanismos de replicación en las soluciones informáticas.

Alineados a la política del estado cubano para lograr la soberanía tecnológica se impone el

uso de soluciones de software libre. Para un mayor rendimiento de los mecanismos de

replicación de datos bajo esta filosofía se requiere un alto nivel de conocimiento y

experticia por parte de los usuarios. Contar con aplicaciones de software libre que faciliten

a los usuarios configurar y administrar este tipo de herramientas es de gran utilidad pues

libera a las empresas de los pagos de licencias de software y aminora los costos de

adquisición de materiales de apoyo, consultorías y solución de problemas.

El valor práctico consiste en la creación de una herramienta administrativa sobre la web

2.0 con el uso de tecnologías libres que permita gestionar las funcionalidades de

SymmetricDS, facilitando a los usuarios finales, mayor usabilidad y explotación del

mecanismo de replicación, así como minimizar los gastos en la producción de software por

el concepto de licencias de software.

El documento está estructurado en tres capítulos que se describen a continuación:

En el Capítulo I. Mecanismos de replicación de datos en Sistemas Gestores de Bases

de Datos se formalizan los principales conceptos de la investigación y se describen

elementos fundamentales sobre los mecanismos de replicación de datos de software libre,

dejando clara la posición del autor. Además se fundamenta la selección de las tecnologías

escogidas para la implementación de la herramienta de administración para el mecanismo

de replicación seleccionado.

INTRODUCCIÓN

5

En el Capítulo II. Modelado de la interfaz de administración para SymmetricDS se

exponen: la arquitectura de la aplicación y el modelado del sistema a través de los

diagramas de casos de uso del sistema, clases, secuencia y modelo físico de la base de

datos.

En el Capítulo III. Implementación y manual de usuario queda representada la

implementación del sistema a través de los diagramas de componentes y despliegue

Además, se especifica a través de un manual de usuario las principales funcionalidades de

la aplicación.

Seguidamente se presentan las conclusiones y las recomendaciones del trabajo, así como

las referencias y bibliografía utilizadas.

CAPÍTULO I

Mecanismos de replicación de datos en SGBD

6

CAPÍTULO I: Mecanismos de replicación de datos en SGBD

La periódica distribución y recopilación de la información ubicada geográficamente

distante resulta una engorrosa tarea a realizar. Con el uso de un mecanismo de réplica de

datos bien configurado y que explote al máximo sus potencialidades se puede automatizar

y lograr buenos resultados en este sentido.

En este Capítulo se tratan los conceptos fundamentales al respecto de los mecanismos de

replicación de datos. Se caracterizan los mecanismos de replicación de software libre más

usados fundamentando la selección del autor. Además se describe y explica la selección de

las tecnologías escogidas para la implementación de la herramienta de administración para

el mecanismo de replicación seleccionado.

1.1 Conceptos generales

Para una buena compresión y entendimiento de este documento es necesario dominar los

conceptos básicos de la replicación de datos en los SGBD. Se hace necesario conocer las

clasificaciones y característica que poseen los mecanismos de replicación. A continuación

se expone un grupo de conceptos y terminologías que se usan en el campo de la replicación

en bases de datos

1.1.1 Replicación

“La replicación copia y mantiene los objetos de las bases de datos en las múltiples bases de

datos que levantan en un sistema distribuido. La replicación puede mejorar el

funcionamiento y proteger la disponibilidad de las aplicaciones, porque alterna opciones de

acceso de los datos existente” (Raúl Monge 2005).

1.1.2 Replicación multimaster

“La replicación multimaster permite múltiples sitios actuando como pares iguales, para

manejar los grupos de objetos replicados en la base de datos. Las aplicaciones pueden

actualizar cualquier tabla replicada en cualquier sitio en una configuración

multimaster”(Raúl Monge 2005).

CAPÍTULO I


7

1.1.3 Propagación sincrónica

“La propagación sincrónica de datos ocurre cuando una aplicación actualiza una

replicación local de una tabla, y dentro de la misma transacción también actualiza el resto

de las replicación de la misma tabla. Por lo tanto, la réplica sincrónica de los datos también

se llama réplica en tiempo real de datos. Se utiliza solamente cuando las aplicaciones

requieren que los sitios replicados sigan sincronizados continuamente” (Raúl Monge 2005).

1.1.4 Replicación heterogénea

La replicación heterogénea no es más que la replicación de datos entre diferentes fuentes de

datos capaces de replicar datos entre diferentes SGBD tales como PostgreSQL, ORACLE,

MySQL, etc.

1.1.1 Replicación lógica

La replicación lógica es el caso en que para lograr la replicación de datos se utilizan

sentencias SQL y no ficheros físicos del gestor de bases de datos.

1.2 SymmetricDS como mecanismo de replicación de datos libre

En el mundo empresarial existen grandes compañías que desarrollan potentes gestores de

base de datos que traen incorporado mecanismos de replicación robustos e interfaces

intuitivas que permiten la configuración y administración de estos mecanismos con

facilidad. Pero ¿resulta esta la mejor opción? La selección de la tecnología apropiada varía

en dependencia a las necesidades y característica que tenga el problema a resolver. En

ocasiones resulta un derroche pagar los altos precios de las licencias de estos mecanismos

privativos, mientras que se puede utilizar tecnologías libres para solucionar estos

problemas.

PostgreSQL por sus características es el gestor libre seleccionado por el país para migrar

las soluciones de bases de datos a software libre. La réplica en este gestor se puede lograr a

través de diferentes mecanismos para tales fines. Sin embargo resulta difícil seleccionar un

mecanismo de replicación para un propósito general, capaz de ser puesto en marcha en

cualquier ambiente de replicación. Por tal motivo en esta investigación se abordaran los

CAPÍTULO I


8

mecanismos de replicación libres que soporta PostgreSQL como una de sus fuentes de

datos.

1.2.1. Slony I

Slony I es un mecanismo de replicación desarrollado específicamente para

PostgresSQL. Es asincrónico, su replicación es lógica y está desarrollado en C y se

integra perfectamente al gestor PostgreSQL. Presenta un sistema de replicación que

puede configurarse para ser de cascada, es decir un servidor cliente de la replicación

puede, a su vez, ser proveedor de datos para otro servidor cliente. Posibilitando

manejar la carga de replicación en los servidores. Es un sistema rápido y que consume

poco recursos en el servidor que se ejecuta. Cuenta con la desventaja de insertar un

trigger3en las bases de datos de los servidores clientes en cada tabla. Además no

permite replicar automáticamente cambios en los objetos largos y los cambios hechos

por comandos DDL4 Se dificulta la instalación y configuración debido a la carencia de

interfaces.

1.2.2. CyberCluster

CyberCluster es un mecanismo de replicación síncrono y multimaestro para la

replicación de datos en PostgreSQL. Presenta Balanceadores de Carga para asegurarse

de que todos los nodos de base de datos pueden ser utilizados durante su normal

funcionamiento. También cuenta con un mecanismo de Manejo de Errores, separando,

al detectar un error, el nodo con problemas de los nodos del sistema de trabajo y sigue

su funcionamiento normalmente en el resto de los nodos. Tan pronto como el nodo con

problemas esté listo, puede ser añadido de nuevo al sistema.

Este mecanismo de replicación permite la recuperación, cuando un clúster bases de

datos se inicia en modo de recuperación, automáticamente se recuperará utilizando un

máster activo. Tiene como desventajas que:

Requiere de una versión modificada del servidor.

3 Trigger: procedimiento que se ejecuta cuando se cumple una condición establecida al realizar una operación de

inserción (INSERT), actualización (UPDATE) o borrado (DELETE en una base de datos). 4 DDL (Data Definition Languaje - lenguaje de definición de datos): lenguaje utilizado para la creación de una base de

datos y todos sus componentes

CAPÍTULO I


9

Cuando se replica objetos grandes deben ser colocados en un directorio que

pueda ser leído por todos los nodos base de datos.

No posee interfaz gráfica para su administración.

1.2.3. PgCluster

PgCluster está desarrollado en C y es un mecanismo de replicación sincrónica y

multimaestro. Su replicación es física, lo que significa que para replicar utiliza los

ficheros del gestor y no los objetos lógicos del mismo. Presenta un servidor para

balancear la carga de las peticiones y permitir que la replicación se realice lo más

rápido posible. Tiene un mecanismo de detección de errores que permite asilar a los

servidores que tengan problema de conexión y continuar con el mecanismo de

replicación sin afectar a los demás servidores.

Este mecanismo posee la funcionalidad de poner en stand-alone5 los clúster de bases

de datos si el servidor de replicación falla. En este modo se puede entrar de 2 formas,

la primera es de modo solo lectura donde solo se le pueden hacer consultas a las bases

de datos; y la segunda es modo lectura – escritura, permitiendo la actualización en las

bases de datos.

Este sistema permite que la replicación y las bases de datos siempre estén disponibles

aunque existan fallos. Emplea un sistema de recuperación, mediante el cual una base

de datos al iniciarse en este modo recupera todos los datos de la base de datos maestra

y al terminar este proceso satisfactoriamente es que se incluye en el sistema de

replicación. Si existen fallos en las bases de datos se pueden recuperar los datos, al

menos, de una copia en buen estado. Cuenta con la desventaja de que la replicación es

sincrónica, si la conexión falla pueden ocurrir errores. Además la replicación es de

forma física por lo que pueden ocurrir errores en la trasferencia de archivos.

1.2.4. Pyreply

Pyreply es un mecanismo asincrónico, multiplataforma y desarrollado en Python. Fácil

instalación y administración aunque es a través de comandos en una terminal. Permite

5 Stand-alone: sistema que puede funcionar por sí mismo.

CAPÍTULO I


10

detención de conflictos y replicación maestro-esclavo y multimaestro. Posee la

desventaja de no soportar objetos grandes y de no contar con una herramienta gráfica

para su administración.

1.2.5. Streaming replication

Streaming replication proporciona la capacidad de enviar de forma continua y aplicar

los registros WAL xlog6 a un cierto número de servidores de base datos en espera con

el fin de mantenerlos actualizados. Se desarrolló para incorporarlo en la distribución

9.0 de PostgreSQL por lo que tiene una buena integración con el gestor. Su instalación

y administración se realiza a través ficheros de configuración y desde una terminal.

1.2.6. DBReplicator

DBReplicator es una suite de software y API diseñado para realizar la replicación

asincrónica. Está desarrollado en Java. Soporta múltiples gestores como fuentes de

datos, y puede ser usado a través de líneas de comandos o una interfaz gráfica. La

interfaz gráfica es de escritorio y pese algunas limitaciones con las llaves primarias y

las restricciones entre bases de datos heterogéneas. La actualización manual puede

afectar el funcionamiento de la réplica, y existen problemas con las columnas auto-

incrementales que son llaves primarias.

1.2.7. SymmetricDS

SymmetricDS es un software de replicación asincrónica, soporta múltiples

suscripciones y de sincronización bidireccional, usa tecnologías web y de bases de

datos para replicar tablas entre bases de datos relacionales. Está desarrollado en Java

lo que le proporciona su carácter multiplataforma, es catalogado como software libre y

de código abierto lo que permite una alta capacidad de incremento de nuevas

funcionalidades, así como la corrección de errores. El software puede ser instalado en

un proceso stand-alone, como una aplicación web en un servidor de aplicaciones de

6 WAL xlog: registros log en PostgreSQL

CAPÍTULO I


11

Java o puede ser embebido en otra aplicación, aumentando con esto las posibilidades

de solución a problemas en múltiples situaciones.

A pesar de contar con grandes potencialidades para ser desplegado en diferentes

ambientes de replicación resulta un poco engorrosa la administración y control del

SymmetricDS, debido a que no cuenta con una interfaz que posibilite la administración

visual de todos los objetos y componentes que contiene el mecanismo.

La selección del mecanismo de replicación adecuado para poder montar un ambiente

de replicación genérico es complejo, pues cada mecanismo posee características

enfocadas a resolver un problema en específico. Sin embargo se pueden clasificar los

mecanismos antes mencionados teniendo en cuenta un grupo de características que

facilitan la implantación de cualquier solución de réplica, como muestra la tabla

siguiente.

Tabla 2: Comparación ente mecanismos de replicación libres para PostgreSQL

Mecanismo de

replicación

Asincronismo Replicación

Lógica

Heterogéneo Multiplataforma

Slony-I X X X

PGCluster

CyberCluster X

Pyreply X X X

Streaming replication X X

DBReplicator X X X X

SymmetricDS X X X X

Como muestra la tabla 2 DBReplication y SymmetricDS son los mecanismos que

mayores posibilidades poseen para montar cualquier ambiente de réplica.

DBReplication es un software con facilidades para los usuarios pues cuenta con

interfaces de usuario para su administración, sin embargo esta ventaja solo es posible

CAPÍTULO I


12

si el computador donde se montará la réplica posee interfaz gráfica. En un ambiente de

producción es recomendable que los servidores tengan Sistemas Operativos a modo

texto por lo que si se desea utilizar DBReplication debe instalarse y administrarse este

software a través de líneas de comandos.

Por otro lado SymmetricDS no posee interfaz de usuario como la mayoría de los

mecanismos antes mencionados, pero por sus características puede ser utilizado en

diferentes situaciones, por ejemplo, puede ser instalado de tres forma diferentes, lo

cual es una ventaja significativa.

La primera variante de instalación es cuando se desea tener el SymmetricDS corriendo

como un servicio más en un sistema operativo, administrándolo a través de líneas de

de comandos en una consola.

La segunda variante instalar SymmetricDS como una aplicación web. Como este

mecanismo hace uso del protocolo HTTP para transportar los datos a través de

Internet, lo que lo hace válido tanto para redes LAN como WAN. Esta característica le

proporciona a SymmetricDS la ventaja de ser usado en un entorno donde las bases

datos se encuentran a gran distancia.

Por último este mecanismo de replicación puede se embebido dentro de una aplicación.

Esta característica es de utilidad cuando se está desarrollando una aplicación y se

desea ejecutar alguna de las funcionalidades que tiene SymmetricDS, haciendo uso del

mecanismo para replicar los datos deseados.

Por lo tanto el autor considera a SymmetricDS como el mecanismo de replicación libre

que soporta a PostgreSQL como una de sus fuentes de datos y que posee la cualidad de

ser utilizado de tres formas diferentes: stand-alone, como aplicación web o embebido

en una aplicación en dependencia de las necesidades del usuario. A pesar de las

funcionalidades que brinda este mecanismo para la replicación de datos SymmetricDS

necesita una herramienta que facilite la interacción de los usuarios con el mismo ya

que estos no se sienten cómodos al utilizarlo.

CAPÍTULO I


13

1.3 Ambiente de desarrollo de la aplicación

Para la creación de software existen tecnologías disponibles para los desarrolladores que

les posibilita la creación de aplicaciones. En los últimos años la web se ha convertido en la

principal opción para la creación de software. Debido a esto han surgido librerías y

herramientas que han evolucionado este mundo en todos los sentidos.

La selección de las tecnologías y herramientas para la creación de aplicaciones web, en una

medida u otra influye en la calidad de las soluciones de software que se desarrollen. Por lo

que esta tarea es un proceso primordial cuando se decide realizar aplicación con eficiencia

y calidad.

El software libre ha tomado partido en el desarrollo de software, siendo la opción de

muchas empresas para lograr resultados favorables y económicos. Para el desarrollo de la

aplicación en esta investigación se optó por usar tecnologías y herramientas libres para su

confección.

1.3.1 Tecnologías

1.3.1.1 Lenguaje de programación del lado del servidor

Los lenguajes de programación del lado del servidor son aquellos que son reconocidos,

ejecutados e interpretados por el propio servidor y que se envían al cliente en un formato

comprensible para él.

1.3.1.1.1 Python

“Python es un lenguaje de scripting independiente de plataforma y orientado a objetos,

preparado para realizar cualquier tipo de programa, desde aplicaciones Windows a

servidores de red o incluso, páginas web. Es un lenguaje interpretado, lo que significa que

no se necesita compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como

la rapidez de desarrollo e inconvenientes como una menor velocidad. En los últimos años

el lenguaje se ha hecho muy popular, gracias a varias razones como:

CAPÍTULO I


14

La cantidad de librerías que contiene, tipos de datos y funciones incorporadas en el

propio lenguaje, que ayudan a realizar muchas tareas habituales sin necesidad de

tener que programarlas desde cero.

La sencillez y velocidad con la que se crean los programas. Un programa en Python

puede tener de 3 a 5 líneas de código menos que su equivalente en Java o C.

La cantidad de plataformas en las que podemos desarrollar, como Unix, Windows,

OS/2, Mac, Amiga y otros.

Además, Python es gratuito, incluso para propósitos empresariales.” (Miguel Angel

Alvarez 2003).

Características de Python:

Propósito general: Con Python se pueden crear todo tipo de programas.

Multiplataforma: Hay versiones disponibles de Python en múltiples sistemas

operativos. Originalmente se desarrolló para Unix, aunque cualquier sistema es

compatible con el lenguaje siempre y cuando exista un intérprete programado para

él.

Interpretado: Quiere decir que no es necesario compilar el código antes de su

ejecución. Aunque en realidad sí que se realiza una compilación, pero esta es

transparente para el programador.

Interactivo: Python dispone de un intérprete por línea de comandos en el que se

pueden introducir sentencias. Cada sentencia se ejecuta y produce un resultado

visible, ayudando a entender mejor el lenguaje y probar rápidamente los resultados

con la ejecución de porciones de código.

Funciones y bibliotecas: Dispone de muchas funciones incorporadas en el propio

lenguaje, para el tratamiento de strings, números, archivos, etc. Además, existen

muchas bibliotecas que pueden ser incorporadas a los programas para tratar temas

específicos como la programación de ventanas o sistemas en red o cosas tan

interesantes como crear archivos comprimidos en .zip.

CAPÍTULO I


15

Orientado a Objetos: La programación orientada a objetos está soportada en

Python y ofrece en muchos casos una manera sencilla de crear programas con

componentes reutilizables.

Sintaxis clara: Python tiene una sintaxis muy visual, gracias a una notación

identada (con márgenes) de obligado cumplimiento. En muchos lenguajes, para

separar porciones de código, se utilizan elementos como las llaves o las palabras

clave begin y end. Para separar las porciones de código en Python se debe tabular

hacia dentro, colocando un margen al código que iría dentro de una función o un

bucle. Esto ayuda a que todos los programadores adopten unas mismas notaciones y

que los programas de cualquier persona tengan un aspecto muy similar.

1.3.1.1.2 Java

Java es un lenguaje de programación que posibilita realizar cualquier tipo de programa. En

la actualidad es un lenguaje muy extendido y cada vez cobra más importancia tanto en el

ámbito de Internet como en la informática en general. Está desarrollado por la compañía

Sun Microsystems con gran dedicación y siempre enfocado a cubrir las necesidades

tecnológicas más punteras.

La independencia de plataforma es una de las razones por las que Java es interesante para

Internet, ya que muchas personas deben tener acceso con ordenadores distintos. Pero no se

queda ahí, Java está desarrollándose incluso para distintos tipos de dispositivos además del

ordenador como móviles, agendas y en general para cualquier cosa que se le ocurra a la

industria.

Características de Java

Lenguaje simple: Java posee una curva de aprendizaje muy rápida. Resulta

relativamente sencillo escribir applets interesantes desde el principio. Todos

aquellos familiarizados con C++ encontrarán que Java es más sencillo, ya que se

han eliminado ciertas características, como los punteros. Los programadores

experimentados en C++ pueden migrar muy rápidamente a Java y ser productivos

en poco tiempo.

CAPÍTULO I


16

Orientado a objetos: Java fue diseñado como un lenguaje orientado a objetos desde

el principio. Los objetos agrupan en estructuras encapsuladas tanto sus datos como

los métodos (o funciones) que manipulan esos datos. La tendencia del futuro, a la

que Java se suma, apunta hacia la programación orientada a objetos, especialmente

en entornos cada vez más complejos y basados en red.

Distribuido: Java proporciona una colección de clases para su uso en aplicaciones

de red, que permiten abrir sockets y establecer y aceptar conexiones con servidores

o clientes remotos, facilitando así la creación de aplicaciones distribuidas.

Interpretado y compilado a la vez: Java es compilado, en la medida en que su

código fuente se transforma en una especie de código máquina, los bytecodes,

semejantes a las instrucciones de ensamblador. Por otra parte, es interpretado, ya

que los bytecodes se pueden ejecutar directamente sobre cualquier máquina a la

cual se hayan portado el intérprete y el sistema de ejecución en tiempo real.

Robusto: Java fue diseñado para crear software altamente fiable. Para ello

proporciona numerosas comprobaciones en compilación y en tiempo de ejecución.

Sus características de memoria liberan a los programadores de una familia entera de

errores (la aritmética de punteros), ya que se ha prescindido por completo los

punteros, y la recolección de basura elimina la necesidad de liberación explícita de

memoria.

Indiferente a la arquitectura: Java está diseñado para soportar aplicaciones que

serán ejecutadas en los más variados entornos de red, desde Unix a Windows NT,

pasando por Mac y estaciones de trabajo, sobre arquitecturas distintas y con

sistemas operativos diversos. Para acomodar requisitos de ejecución tan variados, el

compilador de Java genera bytecodes: un formato intermedio indiferente a la

arquitectura diseñada para transportar el código eficientemente a múltiples

plataformas hardware y software. El resto de problemas los soluciona el intérprete

de Java.

CAPÍTULO I


17

Portable: La indiferencia a la arquitectura representa sólo una parte de su

portabilidad. Además, Java especifica los tamaños de sus tipos de datos básicos y el

comportamiento de sus operadores aritméticos, de manera que los programas son

iguales en todas las plataformas.

Multihebra: Hoy en día ya se ven como terriblemente limitadas las aplicaciones que

sólo pueden ejecutar una acción a la vez. Java soporta sincronización de múltiples

hilos de ejecución (multithreading) a nivel de lenguaje, especialmente útiles en la

creación de aplicaciones de red distribuidas. Así, mientras un hilo se encarga de la

comunicación, otro puede interactuar con el usuario mientras otro presenta una

animación en pantalla y otro realiza cálculos.

Dinámico: El lenguaje Java y su sistema de ejecución en tiempo real son dinámicos

en la fase de enlazado. Las clases sólo se enlazan a medida que son necesitadas. Se

pueden enlazar nuevos módulos de código bajo demanda, procedente de fuentes

muy variadas, incluso desde la Red.

Produce applets: Java puede ser usado para crear dos tipos de programas:

aplicaciones independientes y applets.

Las aplicaciones independientes se comportan como cualquier otro

programa escrito en cualquier lenguaje, como por ejemplo el navegador

de web HotJava, escrito íntegramente en Java.

Por su parte, las applets son pequeños programas que aparecen

embebidos en las páginas web, como aparecen los gráficos o el texto,

pero con la capacidad de ejecutar acciones muy complejas, como animar

imágenes, establecer conexiones de red, presentar menús y cuadros de

diálogo para luego emprender acciones, etc.

1.3.1.2 Lenguaje de programación del lado del cliente

Los lenguajes de lado cliente son aquellos que pueden ser directamente comprendidos por

el navegador y no necesitan un pre tratamiento.

CAPÍTULO I


18

1.3.1.2.1 HTML

Definiéndolo de forma sencilla, "HTML7 es lo que se utiliza para crear todas las páginas

web de Internet". Más concretamente, HTML es el lenguaje con el que se "escriben" la

mayoría de páginas web (Javier Eguíluz Pérez 2008).

HTML es un lenguaje de marcas hipertextuales, diseñado para estructurar textos para

generar páginas web. Gracias a Internet y a los navegadores web, HTML se ha convertido

en el formato más fácil para la creación de páginas web debido a su sencillez.

La mayoría de las etiquetas del lenguaje HTML son semánticas y su interpretación es

realizada por el navegador web. HTML se caracteriza por ser un lenguaje extensible, que se

le pueden añadir características, etiquetas y funciones adicionales para el diseño de páginas

web, generando un producto vistoso, rápido y sencillo.

1.3.1.2.2 Java Script

Java Script es un lenguaje basado en objetos y guiado por eventos, diseñado

específicamente para el desarrollo de aplicaciones cliente-servidor dentro del ámbito de

Internet. Los programas escritos con este lenguaje se pueden probar directamente en

cualquier navegador sin necesidad de procesos intermedios, convirtiéndolo en un lenguaje

interpretado.

Ventajas de JavaScript:

Los programas escritos en este lenguaje no requieren de mucha memoria ni tiempo

adicional de transmisión, por ser pequeños y compactos.

JavaScript no requiere un tiempo de compilación; ya que los scripts se pueden

desarrollar en un período de tiempo relativamente corto.

7 HTML como indican sus siglas significa (HyperText Mark-Up Language), que viene a ser, en nuestro idioma,

“Lenguaje para el Formato de Documentos de Hipertexto”.

CAPÍTULO I


19

Es independiente de la plataforma, hardware o sistema operativo, y funciona

correctamente siempre y cuando exista un navegador con soporte JavaScript.

1.3.1.2.3 CSS

Es un lenguaje de hojas de estilos (Cascading Style Sheets) creado para controlar la

presentación de documentos estructurados y escritos en XHTML, aspectos como: el color,

el tamaño, el tipo de letra, la separación entre párrafos y la tabulación con la que se

muestran los elementos de una lista. El propósito del desarrollo de CSS es separar la

estructura y el contenido de la presentación estética en un documento, esto permite un

control mayor del documento y sus atributos, convirtiendo al XHTML en un documento

muy versátil y liviano.

“Separar la definición de los contenidos y la definición de su aspecto presenta numerosas

ventajas, ya que obliga a crear documentos HTML/XHTML bien definidos y con

significado completo (también llamados "documentos semánticos"). Además, mejora la

accesibilidad del documento, reduce la complejidad de su mantenimiento y permite

visualizar el mismo documento en infinidad de dispositivos diferentes.” (Javier Eguíluz

Pérez 2009).

Ventajas de CSS:

Control de la presentación de muchos documentos desde una única hoja de estilo.

Control más preciso de la presentación.

Aplicación de diferentes presentaciones a diferentes tipos de medios (pantalla,

impresión, etc.)

1.3.1.3 Servidores

1.3.1.3.1 Apache

Apache es un servidor web potente, flexible y disponible para distintas plataformas y

entornos. Es altamente configurable de diseño modular, posibilitando que los

CAPÍTULO I


20

administradores de sitios web puedan elegir los módulos que serán incluidos y ejecutados

en el servidor.

Características de Apache:

Es una tecnología gratuita y de código abierto, lo que proporciona transparencia en

todo el proceso de instalación.

Es prácticamente universal, por su disponibilidad en multitud de sistemas

operativos.

Posee una alta configurabilidad en la creación y gestión de logs, de este modo es

posible tener un mayor control sobre lo que sucede en el servidor.

Este servidor web Apache tiene una fácil integración con varios lenguajes de programación

como: Java, Perl, PHP y especialmente Python. Dicha relación está dada por Mod_python

que es un módulo de Apache que integra el intérprete de Python dentro del servidor.

Con mod_python se pueden desarrollar aplicaciones web basadas en Python que se ejecutan

mucho más rápido que el CGI tradicional y tienen acceso a características avanzadas como

la capacidad de mantener conexiones con la base de datos.

1.3.1.3.2 Tomcat

Apache Tomcat funciona como un contenedor de servlets desarrollado bajo el proyecto

Jakarta en la Apache Software Foundation. Tomcat implementa las especificaciones de los

servlets y de JavaServer Pages (JSP) de Sun Microsystems.

Tomcat es un servidor web con soporte de servlets y JSPs. Tomcat no es un servidor de

aplicaciones, como JBoss o JOnAS. Incluye el compilador Jasper, que compila JSPs

convirtiéndolas en servlets. El motor de servlets de Tomcat a menudo se presenta en

combinación con el servidor web Apache.

Características de Tomcat:

Implementado a partir de Servlet 2.5 y JSP 2.1

Soporte para Unified Expression Language 2.1

CAPÍTULO I


21

Diseñado para funcionar en Java SE 5.0 y posteriores

Soporte para Comet a través de la interfaz CometProcessor

1.3.1.3.2.1. Axis2

Axis2 es el nuevo motor de webservices de Apache Tomcat. Su arquitectura ha sido

diseñada desde cero, teniendo en cuenta las lecciones aprendidas con Axis1. Cabe destacar

su mejor rendimiento, pero sobretodo su sistema de módulos que permite, de forma

sencilla, añadir nuevas funcionalidades y soportar futuras especificaciones sobre

webservices.

Axis2 puede utilizar SOAP 1.1, SOAP 1.2 y REST. Además soporta las especificaciones

WS-Security, WS-ReliableMessaging, WS-Addressing, WS-Coordination y WS-Atomic

Transaction.

1.3.2 Frameworks de desarrollo

Un framework, en el desarrollo de software es una estructura de soporte definida en la cual

otro proyecto de software puede ser organizado y desarrollado.

1.3.2.1 Django

Django es un framework web de código abierto escrito en Python que permite construir

aplicaciones web más rápido y con menos código.

“Django fue inicialmente desarrollado para gestionar aplicaciones web de páginas

orientadas a noticias de World Online, más tarde se liberó bajo licencia BSD. Django se

centra en automatizar todo lo posible y se adhiere al principio DRY (Don't Repeat

Yourself).” (Django Software Foundation 2010).

Características de Django:

Mapeador objeto-relacional.

Aplicaciones integrables que pueden instalarse en cualquier página gestionada con

Django.

API de base de datos robusta.

http://www.oasis-open.org/committees/download.php/16790/wss-v1.1-spec-os-SOAPMessageSecurity.pdf

http://xml.coverpages.org/ws-reliablemessaging20030313.pdf

http://www.w3.org/2002/ws/addr/

http://dev2dev.bea.com/pub/a/2004/03/ws-coordination.html

ftp://www6.software.ibm.com/software/developer/library/WS-AtomicTransaction.pdf

ftp://www6.software.ibm.com/software/developer/library/WS-AtomicTransaction.pdf

http://www.python.org/

http://code.djangoproject.com/browser/django/trunk/LICENSE

http://c2.com/cgi/wiki?DontRepeatYourself

http://es.wikipedia.org/wiki/ORM

http://es.wikipedia.org/wiki/Interfaz_de_programaci%C3%B3n_de_aplicaciones

http://es.wikipedia.org/wiki/Base_de_datos

CAPÍTULO I


22

Un sistema extensible de plantillas basado en etiquetas, con herencia de plantillas.

Un despachador de URLs basado en expresiones regulares.

Un sistema middleware para desarrollar características adicionales.

Documentación incorporada accesible a través de la aplicación administrativa

(incluyendo documentación generada automáticamente de los modelos y las

bibliotecas de plantillas añadidas por las aplicaciones).

1.3.2.2 Hibernate

Hibernate es una herramienta para la plataforma Java que facilita el mapeo de atributos

entre una base de datos relacional y el modelo de objetos de una aplicación, mediante

archivos declarativos (XML) que permiten establecer estas relaciones.

Hibernate es una herramienta ORM completa que ha conseguido en un tiempo record una

excelente reputación en la comunidad de desarrollo posicionándose claramente como el

producto OpenSource líder en este campo gracias a sus prestaciones, buena documentación

y estabilidad. Es valorado por muchos incluso como solución superior a productos

comerciales dentro de su enfoque, siendo una muestra clara de su reputación y soporte la

reciente integración dentro del grupo JBoss que seguramente generará iniciativas muy

interesantes para el uso de Hibernate dentro de este servidor de aplicaciones.

Características Hibernate:

No intrusivo (estilo POJO)

Muy buena documentación (forums para ayuda, libro)

Comunidad activa con muchos usuarios

Transacciones, caché, asociaciones, polimorfismo, herencia, lazy loading,

persistencia transitiva, estrategias de fetching.

Potente lenguaje de consulta (HQL): subqueries, outer joins, ordering, proyección

(report query), paginación.

Fácil de probar.

No es estándar.

http://es.wikipedia.org/wiki/Plantilla

http://es.wikipedia.org/wiki/URL

http://es.wikipedia.org/wiki/Expresi%C3%B3n_regular

http://es.wikipedia.org/wiki/Plataforma_Java

http://es.wikipedia.org/wiki/Base_de_datos

http://es.wikipedia.org/wiki/Objetos_%28programaci%C3%B3n_orientada_a_objetos%29

http://es.wikipedia.org/wiki/XML

CAPÍTULO I


23

1.3.3 Bibliotecas

Las bibliotecas en el desarrollo de software son de gran importancia, ya que enriquecen los

lenguajes de programación incorporando funcionalidades nuevas y facilitando el trabajo

con los mismos.

1.3.3.1 ExtJS

ExtJS es una biblioteca Java Script de componentes gráficos, que facilita las herramientas

necesarias para la creación de aplicaciones web. Posee una considerable colección de

componentes para el diseño de interfaces, ventanas cuadros de diálogo, menús, tablas

editables, layouts, paneles, pestañas y todo lo necesario para construir atractivos desarrollos

al estilo de la web 2.0.

ExtJS brinda soporte para:

Construir interfaces gráficas complejas y dinámicas.

Comunicar datos de forma asíncrona con el servidor.

Diversos navegadores como: Internet Explorer, Firefox, Safari y Opera.

ExtJS incluye componentes UI8 del alto rendimiento y personalizables, modelo de

componentes extensibles, un API fácil de usar y presenta dos tipos de licencia open source

y comercial.

Beneficios de ExtJS:

Existe un balance entre Cliente – Servidor: La carga de procesamiento se

distribuye, permitiendo que el servidor, al tener menor carga, pueda manejar más

clientes al mismo tiempo.

Comunicación asíncrona: En este tipo de aplicación el motor de render puede

comunicarse con el servidor sin necesidad de estar sujeta a un clic o una acción del

usuario, dándole la libertad de cargar información sin que el cliente se dé cuenta.

8 UI (User Interface): La interfaz de usuario es el sistema a través del cual las personas (usuarios) pueden interactuar

con las maquinas.

CAPÍTULO I


24

Eficiencia de la red: El tráfico de red puede disminuir al permitir que la aplicación

elija que información desea transmitir al servidor y viceversa, sin embargo la

aplicación que haga uso de la pre-carga de datos puede que revierta este beneficio

por el incremento del tráfico.

1.3.3.2 Suds

SUDS es un ligero cliente SOAP python para consumir servicios web.

Características de Suds

No requiere generación de la clase

Lee wsdl en tiempo de ejecución para la codificación / decodificación

Compatible con los siguientes estilos de SOAP:

Document/Literal

RPC/Literal

RPC/Encoded

Proporciona la objetivación de WSDL definiendo:

Tipos (objetos)

Enumeraciones

Facilita la inspección de servicios y objetos utilizando la función print

Soporte Unicode

Autentificación HTTP

WS-Security básico

1.3.4 Herramientas

Las herramientas de desarrollo son aquellos programas o aplicaciones que tienen gran

importancia en el desarrollo de un programa, apoyando el proceso activo de construcción

del mismo.

1.3.4.1 Visual Paradigm

Visual Paradigm para UML (VP-UML) es una poderosa herramienta CASE

multiplataforma (Windows/Linux/Mac OS X) que soporta el ciclo de vida completo del

desarrollo de software. Está diseñado para un amplio rango de usuarios, incluyendo

CAPÍTULO I


25

ingenieros de software, analistas de sistema, analistas de negocio, arquitectos de sistema y

quienes estén interesados en la construcción de sistemas de software confiables mediante el

uso de la Orientación a Objetos.

Este software facilita una rápida construcción de aplicaciones de calidad y a un menor

coste. Visual Paradigm para UML soporta un conjunto de lenguajes (Java, C++, PHP, Ada

y Python), tanto en generación de código como ingeniería inversa.

Entre sus características principales se pueden citar:

Soporta UML en su versión 2.1.

Facilita la comunicación de todo el equipo de desarrollo mediante el uso de un

lenguaje estándar común.

Posibilita el desarrollo de la ingeniería directa e inversa.

Durante todo el ciclo de desarrollo el modelo y el código permanecen

sincronizados, permitiendo la generación de código a partir de diagramas y

viceversa.

Se encuentra disponible en múltiples versiones y plataformas.

Permite la generación de bases de datos a partir de la transformación de diagramas

de Entidad-Relación en tablas de base de datos y viceversa.

1.3.4.2 Eclipse

Eclipse es un entorno de desarrollo integrado (IDE, Integrated Development Environment)

de código abierto y multiplataforma, que facilita enormemente las tareas de edición,

compilación y ejecución de programas durante su fase de desarrollo.

Características de Eclipse

Dispone de un Editor de texto con resaltado de sintaxis

La compilación es en tiempo real.

Tiene asistentes (wizards) para creación de proyectos, clases, tests, etc.

La principal ventaja que posee Eclipse es la cantidad de pluings con que se cuenta, los

cuales posibilita desarrollar en cualquier lenguaje de programación así como utilizar

herramientas que facilitan el trabajo a los desarrolladores en la elaboración de aplicaciones.

CAPÍTULO I


26

A continuación se mencionan los pluings utilizados para el desarrollo de la aplicación

Pydev para el trabajo con Python

Subversive para el control de versiones del código fuente de la aplicación

JavaWeb para el desarrollo del código fuente del servicio web

Servicio web para la generación del servicio web

Servers para la integración del servidor web Apache Tomcat y Axis2 en el Eclipse

Hibernate Tool herramienta para la generación de las clases el modelo del ORM

Hibernate.

1.4 Conclusiones del capítulo

Después de realizar un estudio de los principales mecanismos de replicación libres

existentes en el mundo, se llegó a la conclusión que SymmetricDS es una buena alternativa

a usar en Cuba durante el proceso de migración, posibilitando la replicación de datos entre

diferentes gestores de base de datos, incluido PostgreSQL.

Para una mayor aceptación del mecanismo por los usuarios, se plantea el desarrollo de una

herramienta web que posibilite administrar SymmetricDS de forma sencilla e intuitiva.

Utilizando para su elaboración tecnologías y herramientas libres.

CAPÍTULO II

Modelado de la interfaz de administración para SymmetricDS

27

CAPÍTULO II: Modelado de la interfaz de administración para

SymmetricDS

La planificación y documentación durante la elaboración de un sistema de software es de

vital importancia, determinando la calidad del producto final. Además, sirve de guía al

desarrollador para saber en qué estado se encuentra la aplicación y orienta el camino a

seguir durante la implementación de la misma. De esta forma se trabaja más

organizadamente y queda un historial a consultar para el diseño de nuevas aplicaciones.

En este capítulo se representan los principales diagramas del diseño de la aplicación, así

como una detallada descripción de la arquitectura del sistema y funcionamiento del

mecanismo de replicación SymmetricDS.

2.1. SymmetricDS

Para SymmetricDS una base de datos representa un nodo, el cual es inicializado en un

fichero de propiedades y configurado con la inserción de un grupo de datos de

configuración, en tablas de la base de datos. También se crean disparadores de base de

datos en las tablas de la réplica, para permitir la sincronización. En la base de datos, los

eventos son capturados para posteriormente ser enviados a otro nodo SymmetricDS.

SymmetricDS utiliza los términos nodo registrador y nodo hijo para su configuración. Esto

implica que el nodo registrador posee toda la configuración del mecanismo de replicación,

la cual es enviada automáticamente a todos los nodos hijos que son registrados al mismo.

Por su parte los nodos hijos deben ser registrados a un nodo registrador, para cargar la

configuración del ambiente de réplica almacenada en el nodo registrador, además de

realizar la cargada inicial de los datos para la sincronización entre los nodos SymmetricDS

involucrados en un ambiente de réplica.

CAPÍTULO II


28

El mecanismo de replicación crea un conjunto de tablas de metadatos en la base de dato de

la réplica, sobre las que se almacena la configuración de los componentes de

SymmetricDS, para posteriormente ser enviada esta configuración de los nodos

registradores a los nodos hijos.

A continuación se describen cada uno de los componentes de SymmetricDS:

SymmNodeGroup: permite agrupar un conjunto de nodos que contienen datos

comunes a replicar y tiene como propiedad un nombre y una descripción.

SymmNodeGroupLink: tiene la funcionalidad de establecer un vínculo entro dos

grupos, definiendo que entre ellos se van a intercambiar datos y especificando la

dirección en que los datos serán enviados. SymmNodeGroupLink tiene como

propiedades un grupo origen, un grupo destino y un evento da datos que pueden ser

PUSH o WAINT FOR PUSH.

SymmChannel: consiste en establecer un canal para el envío de datos desde un

SymmNodeGroup a otro. Para crear un SymmChannel se definen un grupo de

parámetros como orden de procesamiento de los datos, tamaño máximo y mínimo

de envío, periodo de extracción etc. Permitiendo con ello personalizar el canal para

adaptarlo al ambiente de replicación.

SymmTrigger: define las tablas y columnas a replicar en la base de datos. Los

SymmTrigger utilizan los SymmChannel para el transporte de los datos, es decir se

especifica las tablas de donde se toman los datos a replicar.

SymmRouter: precisan las tablas donde serán enviados los datos, especificándose el

nodo origen y destino.

SymmTriggerRouter: se encargan de realizar un acople entre los SymmTrigger y

los SymmRouter, especificando que de una tabla definida en el trigger se enviarán

sus datos a una tabla definida en el router.

SymmNode: es una instancia de SymmetricDS que tiene una base dato asociada

para la réplica.

CAPÍTULO II


29

SymmetricDS está desarrollado para brindar escalabilidad, sin embargo esto no quiere

decir que no se pueda utilizar para ambientes de disponibilidad o rendimiento. El ambiente

ideal para su uso es cuando los nodos se encuentran ubicados geográficamente distantes y

se requiere replicar un grupo de tablas. Esto es posible debido a que SymmetricDS envía

los datos a replicar a través del protocolo HTTP, facilitando con ello la replicación en redes

WAN.

En caso de presentar problemas de rendimiento con el gestor, se puede instalar la instancia

de SymmetricDS en otro host, dándole la carga de replicación a este host para obtener un

equilibrio entre el rendimiento del gestor y el mecanismo de replicación.

SymmetricDS está desarrollado en Java 5, haciendo uso del marco de trabajo Sprint por lo

que requiere una máquina virtual de Java 5 o superior y el manejador JDBC de las bases de

datos que soporte, las cuales deben contar con tecnologías de disparadores. SymmetricDS

soporta bases de datos como MYSQL, Oracle, PostgreSQL, SQLServer, H2, IBMDB2 ente

otras

2.2. Arquitectura del sistema

La herramienta de administración propuesta a desarrollar debe cumplir con el propósito de

administrar todas las instancias SymmetricDS implicadas en un entorno de replicación.

Aprovechando la variante de instalación de SymmetricDS sobre un servidor web, se optó

por configurar las instancias de SymmetricDS en un servidor de web Apache Tomcat.

En un entorno de replicación pueden existir varios servidores de web Tomcat, y a su vez en

cada servidor Tomcat pueden existir varias instancias SymmetricDS. Esto dificulta la

administración de las instancias antes mencionadas, por lo que se decidió crear un servicio

web que administre las instancias SymmetricDS de un servidor Tomcat.

El servicio web se desarrollará en java con el propósito de configurarlo en el mismo

servidor de aplicaciones donde estarán las instancias de SymmetricDS, haciendo uso del

Axis2 para su publicación. La configuración de la réplica se encuentra en las tablas de

CAPÍTULO II


30

metadatos de las bases de datos asociadas a las instancias SymmetricDS, lo que implica

que el servicio web utilizará el ORM Hibernate para acceder a estas tablas y configurar los

nodos.

También se desarrollará una aplicación web sobre Python con el uso del marco de trabajo

Django con el objetivo de que los usuarios administren las instancias SymmetricDS,

auxiliándose del servicio web. Esta aplicación hará uso del servicio web mediante la

biblioteca de Python SUDS, que es un cliente de servicio web que facilita la integración de

Python con los servicios web. Las interfaces de usuarios se implementarán auxiliándose de

la biblioteca JavaScript ExtJS simulando un ambiente de escritorio. Esta integración de

tecnologías puede verse reflejada en la figura 1.

Figura 1: Diagrama de integración de tecnologías

Para logar el funcionamiento de la réplica con la interfaz, es necesario que SymmetricDS

pueda contar con un servidor web Apache y uno o varios servidores web Tomcat. En el

CAPÍTULO II


31

servidor Apache se publicará la aplicación en Django, que deberá tener accesos a los

servicios web implicados en la réplica. Por otra parte, en el servidor Tomcat tendrá

instalado Axis2 que estará encargado de publicar el servicio web que administre las

instancias SymmetricDS creadas en el servidor Tomcat. Además desde el servicio web se

debe tener acceso a las bases de datos implicadas en la réplica, pues éste gestiona las tablas

de metadatos que genera SymmetricDS en las bases de datos asociada. El diagrama de

interacción entre aplicaciones se observa en la figura 2.

Figura 2: Diagrama de interacción ente las aplicaciones de la herramienta

2.3. Componentes de la Herramienta

Los conceptos o componentes que usa SymmetricDS para llevar a cabo una réplica son

difíciles de comprender pues, el mecanismo crea un ambiente de interacción entre estos

componentes y los almacena en las tablas de los nodos a replicar, lo provoca que los

usuarios no definan claramente las interrelaciones entre los componentes.

Para un mejor entendimiento de estos componentes, se decidió abstraer a los usuarios del

funcionamiento del mecanismo de replicación. Es por esto que se creó un ambiente más

sencillo, con un conjunto de conceptos que permiten configurar y administrar un ambiente

de réplica sin contar con un alto nivel de conocimiento de SymmetricDS. A continuación

se describe cada concepto.

Set: Un set de replicación es un ambiente de replicación que agrupa un conjunto

de componentes necesarios para lograr una réplica de datos.

CAPÍTULO II


32

Servicio de Administración: Es un servicio web que gestiona un grupo de

instancias SymmetricDS en un servidor Tomcat. Además permite gestiones los

componentes de SymmetricDS creados en las bases de datos asociadas a las

instancias antes mencionadas.

Canal: Es un canal donde viajarán los datos a replicar, el mismo se puede

configurar con un grupo de características, dependiendo de los recursos y

necesidades de los usuarios. Es el equivalente del Channel de SymmeticDS. Los

canales pertenecen a un Set y no puede existir canales con el mismo nombre en

un set.

Grupo: Un grupo pertenece a un set, y tiene el fin de agrupar un grupo de nodo

que replican datos en común. Es el equivalente de GroupNode de SymmetricDS.

Vínculo de Grupo: Un vínculo relaciona dos grupos, definiendo el sentido en

que viajaran los datos y en que evento serán enviados. Es el equivalente del

LinkNodeGroup de SymmetricDS.

Disparador: En el disparador se define la tabla en que se tomarán los datos para

replicarlos una vez que se realice una inserción, actualización o eliminación

sobre la tabla, también se define por cuál canal serán enviado los datos. Es el

equivalente del SymTrigger de SymmetricDS.

Ruter: En el ruter se define un grupo origen y un grupo destino, especificando

que se enviaran los datos desde el grupo origen al destino. Es el equivalente al

SymRouter de SymmetricDS. En el router se puede especificar opcionalmente el

nombre de la tabla destino, esto es en caso de que la tabla a replicar no tenga el

mismo nombre en el nodo origen que en el destino.

Disparador-Ruter: El fin de este concepto es relacionar un disparador con un

ruter. En el mismo se define un disparador y ruter. Quedando configurado de

manera tal que los datos capturados por el disparador seleccionado que se

encuentren en el grupo origen del ruter seleccionado, serán enviado al grupo

destino especificado en el ruter seleccionado, si existe un vínculo con ese sentido

entre los grupos del ruter. Es el equivalente al Trigger-Router de SymmetricDS.

Nodo: Un nodo es una instancia de SymmetricDS, y una instancia de

SymmetricDS es una aplicación web en java (WAR), la cual contiene las

CAPÍTULO II


33

bibliotecas (jars) de SymmetricDS y los manejadores jdbc de las bases de datos

que soporta el mecanismo. La instancia de SymmetricDS además posee un

fichero de propiedades con las características del nodo. Un nodo pertenece a un

grupo, además un set tiene entre sus grupos un nodo registrado el cual replica la

configuración a sus nodos hijos. El primer nodo que se crea en el set es el nodo

registrador del set y el resto de los nodos creados en el set son nodos hijo del

nodo antes mencionado. Este concepto abarca los conceptos SymNode, nodo

registrador y nodo hijo de SymmetricDS. En un nodo se especifica el servicio de

administración que lo gestiona.

2.4. Casos de uso del sistema

Con las funcionalidades de la herramienta de administración de SymmetricDS se persigue

brindar a los usuarios de este mecanismo de replicación, una herramienta administrativa

que permita configurarla y administrarla de forma rápida, sencilla e intuitiva.

Figura 3: Diagrama de casos de uso del sistema

CAPÍTULO II


34

El diagrama de CU del sistema de la figura 3 consta de 11 CU, de ellos uno es incluido al

caso de uso Gestionar Nodo. Cada caso de uso incluye las funcionalidades crear, modificar

y eliminar, excepto Gestionar Instancia de SymmetricDS, el cual incluye las

funcionalidades:

Ver estado del Nodo

Iniciar Nodo

Detener Nodo

Reiniciar Nodo

El actor que inicia los CU es un usuario, que puede ser el administrador de base de datos,

dado que debe dominar el funcionamiento del mecanismo de replicación SymmetricDS y

que conozca las credenciales de acceso a las bases de datos a replicar.

A continuación se describe el CU Gestionar Nodo considerado uno de los más importantes

en la aplicación. Para una mejor descripción se dividió el caso de uso en 3 CU:

Crear Nodo

Eliminar Nodo

Modificar Nodo

Descripción caso de uso Crear Nodo

Tabla 3: Descripción del caso de uso Crear Nodo

Caso de Uso: Crear Nodo

Actores: Usuario

Resumen: El caso de uso se inicia cuando el usuario selecciona en el árbol de

componentes uno de los grupos creados. Una vez seleccionado

este, elige la opción Crear Nodos. Donde el sistema muestra un

formulario con los campos a llenar y se introducen los datos,

finalizando así el CU.

CAPÍTULO II


35

Precondiciones: Debe existir un grupo creado.

Referencias

Prioridad

Flujo Normal de Eventos

Sección “Crear Nodo”

Acción del Actor Respuesta del Sistema

1. El usuario selecciona en el árbol de

componentes uno de los grupos creados.

2. Una vez seleccionado el grupo el

sistema nos permite seleccionar la

opción de crear un nuevo nodo.

3. El usuario selecciona la opción Crear. 4. Muestra la interfaz Crear Nodos, que

posee los siguientes componente:

Nombre

Servicio

Gestor

Host

Puerto

Nombre BD

Usuario

Clave

5. El usuario introduce los datos solicitados.

6. El usuario selecciona la opción Aceptar. 7. Comprueba que no existan campos

vacios.

8. Crea el nuevo nodo con los datos

introducidos por el usuario.

9. Retorna a la interfaz principal de la

aplicación y refresca el árbol de

componentes.

CAPÍTULO II


36

Prototipo de Interfaz

Flujos Alternos

Flujo Alterno 2a No se selecciono un grupo.


2a.1 Comprueba que se haya

seleccionado el grupo.

2a.2 Muestra el mensaje de información

“Debe seleccionar un grupo”.

2a.3 El usuario selecciona la opción

Aceptar.

2a.4 Retorna a la interfaz principal de la

aplicación.

2a.5 El usuario selecciona en el árbol de

componentes uno de los grupos creados.

2a.6 Permite seleccionar nuevamente la

opción de crear un nuevo nodo.

CAPÍTULO II


37


Flujos Alternos

Flujo Alterno 7a Existen campos vacios.


7a.1 Comprueba que existen campos

vacios.

7a.2 Muestra el mensaje de información

“Faltan campos por llenar”.

7a.3 El usuario selecciona la opción

“Aceptar”.

7a.5 Muestra nuevamente la interfaz

Crear Nodos para reiniciar el proceso de

entrada de datos.


Poscondiciones Nodo creado.

CAPÍTULO II


38

Descripción del caso de uso Eliminar Nodo

Tabla 4: Descripción del caso de uso Eliminar Nodo

Caso de Uso: Eliminar Nodo

Actores: Usuario


componentes uno de los nodos creados. Una vez seleccionado este,

elige la opción Eliminar Nodos y el sistema muestra un mensaje

para confirmar, finalizando así el CU.

Precondiciones: Debe existir el nodo.

Referencias

Prioridad


Sección “Eliminar Nodo”



componentes uno de los nodos creados.

2. Una vez escogido el nodo el sistema

permite seleccionar la opción de

Eliminar nodo.

3. El usuario selecciona la opción Eliminar. 4. El sistema muestra un mensaje

“¿Confirma que desea eliminar el

nodo?”.

5. El usuario selecciona la opción Aceptar.

6. Elimina el nodo seleccionado.

7. Retorna a la interfaz principal de la

aplicación y refresca el árbol de

componentes.

CAPÍTULO II


39


Flujos Alternos

Flujo Alterno 2a No se selecciono un nodo.


2a.1.Comprueba que se haya

seleccionado el nodo.

2a.2.Muestra el mensaje de información

“Debe seleccionar un nodo”.

2a.3.El usuario selecciona la opción

Aceptar.

2a.4.Retorna a la interfaz principal de la

aplicación.

2a.5.El usuario selecciona en el árbol de


2a.6.Permite seleccionar nuevamente la

opción de Eliminar Nodo.


Flujos Alternos

Flujo Alterno 5a No desea eliminar

CAPÍTULO II


40


5a.1.Si el usuario selecciona la opción

Cancelar, finaliza el CU.


Poscondiciones Nodo eliminado.

Descripción caso de uso Modificar Nodo

Tabla 5: Descripción del caso de uso Modificar Nodo

Caso de Uso: Modificar Nodo

Actores: Usuario


componentes uno de los nodos creados. Una vez seleccionado este,

elige la opción Modificar Nodos. El sistema muestra un formulario

con los datos del nodo seleccionado, el usuario realiza los cambios

que desea e indica modificar, finalizando así el CU.

Precondiciones: Debe existir el nodo.

Referencias

Prioridad


Sección “Modificar Nodo”

CAPÍTULO II


41



componentes uno de los nodos

creados.

2. Una vez escogido el nodo el

sistema permite seleccionar la

opción Modificar nodo.

3. El usuario selecciona la opción

Modificar.

4. Muestra la interfaz Modificar

Nodos, que posee los siguientes

componente:

Nombre

Servicio

Gestor

Host

Puerto

NombreBD

Usuario

Clave

5. El usuario modifica los datos del

nodo deseado.

6. El usuario selecciona la opción

Aceptar.

7. Comprueba que no existan

campos vacios.

8. Modifica el nodo con los datos

introducidos por el usuario.

9. Retorna a la interfaz principal de

la aplicación y refresca el árbol

de componentes.

CAPÍTULO II


42


Flujos Alternos

Flujo Alterno 2a No se selecciono un nodo.


2a.1.Comprueba que se haya

seleccionado el nodo.


“Debe seleccionar un nodo”.


Aceptar.

2a.4.Retorna a la interfaz principal de la

aplicación.

2a.5.El usuario selecciona en el árbol de


2a.6.Permite seleccionar nuevamente la

opción de Modificar Nodo.

CAPÍTULO II


43

Flujos Alternos

Flujo Alterno 7a Existen campos vacios.


7a.1 Comprueba que existen campos

vacios.


“Faltan campos por llenar”.


Aceptar.

7a.5.Muestra nuevamente la interfaz

Modificar Nodo para reiniciar el proceso

de entrada de datos.


Poscondiciones Nodo modificado.

2.5. Diagramas de clases

El modelado y definición de clases en una solución de software es un elemento de vital

importancia en el desarrollo de aplicaciones informáticas, por lo tanto en este proceso se

debe ser cuidadoso y minucioso, tratando de dejar reflejado en los diagramas de clases la

solución propuesta al problema en cuestión.

Para el desarrollo de la herramienta se hizo necesario crear dos aplicaciones las cuales

están implementadas en lenguajes de programación diferentes, una aplicación web de

CAPÍTULO II


44

interfaz gráfica en Python y un servicio web en Java. A continuación se detallan los

diagramas de clases de cada una de ellas.

2.5.1. Diagrama de clases de la aplicación en Django (Python)

Figura 4: Diagrama de clases de la aplicación web

CAPÍTULO II


45

A continuación se realiza una breve descripción de las clases representadas en el diagrama

de clases de la figura 4:

ClientWebService: Esta clase es la encargada de crear un cliente para el acceso al

servicio web haciendo uso de la biblioteca suds. Desde esta clase se pueden ejecutar

los métodos del servicio, así como crear instancias de las clases que se pasan como

parámetro en los métodos del servicio. En ella se especifica la url donde está

publicado el servicio web a consumir.

AppMessage: Esta clase en utilizada preferentemente en las vistas del proyecto

Django y su función es encodar y desencodar a formato JSON los datos en la

aplicación. En caso de encodar se transforma las listas y los diccionarios de Python

a Objetos JavaScript, y cuando se desencoda los arreglos o objetos JavaScript son

convertidos en listas o diccionarios Python respectivamente. Hace uso del módulo

simpleJson de Django.

TreeObjectManager: La función de esta clase es proporcionarle al árbol explorador

de la interfaz los nodos a cargar en cada nivel del árbol.

SetManager: Esta clase controla todas las acciones referentes a un Set, las cuales

incluye crear, editar y eliminar un Set. Otras de sus funcionalidades es retornar las

características de los Sets, así como devolver el nodo registrador asociado al Set

especificado. Esta clase hace uso del las clases del modelo definida en el modulo

models.py de las aplicaciones del proyecto Django.

CAPÍTULO II


46

DataViewManager: Esta clase es similar a la TreeObjectManager, pues su

propósito es brindarle a la interfaz los componentes a ser visualizados en el

DataView de la aplicación.

ServiceManager: Esta clase gestiona la información referente al trabajo con los

Servicios de Administración. Brinda la funcionalidad de verificar si los datos

introducidos están realmente asociado con un servicio web.

Además permite crear, editar y eliminar un Servicio de Administración, además

retornar un ClientWebService para el trabajo con los servicios web.

NodeManager: Esta clase gestiona los objetos Nodos de la aplicación, sus

funcionalidades incluye crear, eliminar, ver el estado, iniciar, detener y reiniciar los

nodos. Para ello se auxilia de las clases del modelo y los métodos del servicio web

asociado al nodo para estas tareas.

Las clases GroupSymManager, ChannelManager, RuterSymManager,

SymmTrigger, RuterTriggerManager, LinkSymManager: tienen como tarea

principal la gestión de los objetos del mecanismo SymmetricDS, brindado la

funcionalidades de crear, modificar y eliminar los objetos, auxiliándose para ello de

las clases del modelo y los métodos de los servicios web.

La clase Views es un módulo del proyecto Django para visualizar las vistas de la

aplicación.

2.5.2. Diagrama de clases del servicio web

CAPÍTULO II


47

Figura 5: Diagrama de clases del servicio web

A continuación se realiza una breve descripción de las clases representadas en el diagrama

de clases de la figura 5:

CommandManager: Esta es una clase auxiliar que permite ejecutar un grupo de

comandos SHELL sobre el computador donde esta publicado el servicio web.

Permite copiar, mover y eliminar directorios, así como ejecutar un conjunto de

comandos de SymmetricDS para su administración.

DatabaseManager: La función de esta clase es crear una sección de Hibérnate con

la propiedades definidas en el fichero symmetric.conf creado en cada instancia de

SymmetricDS. Además esta clase prueba los datos de la conexión a la base de

datos.

CAPÍTULO II


48

SymmProperties: Gestiona los ficheros de configuración de las instancias

SymmetrciDS. En estos ficheros se define un conjunto de parámetros (usuario,

contraseña, base de datos, tipo de gestor, etc.) necesarios para el correcto

funcionamiento de la réplica. Brinda funcionalidades para crear y leer estos ficheros

así como cambiar o devolver alguno de los parámetros que se definen.

SymmetricManager: La responsabilidad de esta clase es gestionar las instancias de

SymmetricDS. Realiza tareas como:

Crear instancias SymmetricDS.

Publicar instancias SymmetricDS.

Despublicar instancias SymmetricDS.

Eliminar instancias SymmetricDS.

Crear las tablas del SymmetricDS en la base de dato.

Registrar un nodo hijo a un nodo registrador.

Realizar la carga inicial de los datos.

Eliminar las tablas de SymmetrcDS en la base de datos.

Devolver el estado de un nodo

Las clases LinkGroupManager, ChannelManager, TriggerManager,

NodeManager, RouterManager, Trigger-RouterManager, GroupManager,

NodeIdentityManager: son las encargadas de gestionar la configuración de los

componentes de SymmetricDS, los cuales están almacenados en las tablas de

metadatos de la base de dato de cada instancia de SymmetricDS. Las mismas hacen

uso de las clases del domino de Hibernate para la creación, modificación y

eliminación de los componentes.

SymmServiceControl: En esta clase de implementó los métodos del servicio web, la

cual recoge todas las funcionalidades del servicio web, auxiliándose para ello de las

clase controladores antes descritas.

CAPÍTULO II


49

SymmWebService: Esta clase se creó con el fin de generar el servicio web, en la

misma se define oficialmente los nombre los parámetros y el formato de los datos

devueltos por los métodos del servicio web.

2.6. Diagramas de secuencias

La comunicación entre las clases de la aplicación es muy alta debido a las dependencias

existentes entre las mismas. Los componentes de SymmetricDS se relacionan entre sí

logrando una integración que funciona como un todo.

La aplicación web de Django crea las interfaces de usuarios a través de las vistas de,

además se crearon clases controladoras para cada objeto que se gestione en la aplicación.

Por otra parte se crearon clases auxiliares para consumir de servicios web, encodar en

formato JSON y gestionar los datos a mostrar en el árbol y el data view de la aplicación.

Las clases del modelo de Django fueron utilizadas para el acceso a la base de datos de la

aplicación. Cada clase controladora hace uso de la clase auxiliar para llamar los métodos de

servicio web necesarios y utiliza la clases del modelo para la interacción con las tablas de

la base de datos.

El servicio web, por otro lado, tiene clases auxiliares para crear conexiones Hibernate a las

base de datos según el tipo de gestor, ejecutar comandos SHELL y realizar trabajo con

ficheros de propiedades. Las clases del domino de Hibernate son utilizadas para el acceso

de la bases de datos. También existen clases controladoras para cada objeto de

SymmetricDS que hacen uso de las clases del domino. Se define una clase controladora

para gestionar las instancias de SymmetricDS que se auxilia de la clase comandManager

para ejecutar comandos SHELL. El servicio web tiene, además, una clase general que

implementa los métodos del servicio web.

La mejor forma de representar la comunicación entre estas clases es a través de diagramas

de secuencias. A continuación se representa los diagramas de secuencias de los casos de

uso Crear nodo y Eliminar nodo, uno de los objetos más complicados en gestionar a través

de la aplicación.

CAPÍTULO II


Figura 6: Diagrama de secuencia para el caso de uso Crear nodo

CAPÍTULO II


Figura 7: Diagrama de secuencia para el caso de uso Eliminar nodo

CAPÍTULO II


52

En la figura 6 se refleja el diagrama de secuencias del caso de uso crear nodo, donde se

representa al usuario introduciendo los datos en el formulario de Crear Nodo. Luego los

datos son enviados a la vista de Django a través de una consulta AJAX. En la vista se

accede a la clase controladora de los Sets para verificar si en el set donde se va a crear el

nodo existe nodo registrador.

En caso de que no exista nodo registrador se accede al servicio web para ejecutar el método

que crea un nodo registrador. Ya en el servicio web la clase ServiceControlManager hace

uso de la clase SymmetricManager para ejecuta el método que crea las instancias

SymmetricDS (WAR).Luego crea las tablas en la base de datos asociada a la instancia y

finalmente por medio de las clases del dominio inserta en la tabla symNode de la base de

dato la información del nodo.

En caso de existir nodo registrador se ejecuta el método del servicio web para crear un

nodo hijo, el cual consiste en insertar la información referente al nodo en la base de dato

del nodo registrador asociado al set que pertenece en nuevo nodo. Luego se registra el nodo

hijo en la instancia de SymmetricDS del nodo registrador. Como última acción se inserta el

nodo en la base de datos de la aplicación Django y se le informa al usuario que la operación

terminó con éxito.

En el caso de uso Eliminar nodo como muestra la figura 7, el usuario solicita a la

aplicación eliminar un nodo. Esta acción llega a la vista a través de una consulta AJAX, la

vista como respuesta le pide al servicio web el estado del nodo a eliminar.

Si el estado del nodo es “detenido” se procede a verificar la dependencia del nodo respecto

al resto de los objetos del set al que pertenece el nodo. En caso de no existir dependencia se

ejecuta el método del servicio web de eliminar la instancia SymmetricDS, con ello viene

incluido eliminar las tablas de metadatos creadas por el mecanismo en la base de dato.

Una vez hecho esto se procede a eliminar la información del nodo en el nodo registrador

del set. Para finalizar la acción se elimina el nodo en la base de dato de la aplicación de

Django y se le informa al usuario que la operación se termino con éxito.

CAPÍTULO II


53

Si existe dependencia de los objetos del set con el nodo se lo informa al usuario que no se

puede eliminar el nodo debido a que existen dependencias.

Si el estado del nodo no es detenido se le informa al usuario que el nodo debe de estar

detenido para realizar dicha acción.

2.7. Diseño de la base de dato

Como la mayoría de las aplicaciones de gestión la herramienta de administración de

SymmetricDS necesita tener datos persistentes. Para ello utiliza un fichero llamado

dbmetadatos.db en el cual se encuentra una base de datos SQLite. Si la configuración de

SymmetricDS se encuentra en las tablas de metadatos de las base de datos de las instancias

de SymmetricDS, ¿Por qué tener una base de dato en SQLite para estos propósitos? Dado

que en la herramienta se gestionan objetos adicionales que no se encuentran en la

configuración del mecanismo, como es el caso de los Set y los Servicios de administración

es que se hace necesario el uso de una base de datos. En el momento que se crea un Nodo

es cuando se escoge la base de datos donde contendrán la configuración de la réplica y se

generan las tablas, sin embargo, los usuarios pueden crear objetos de SymmetricDS sin

haber creado un nodo previamente. Por lo tanto todos los objetos creados antes de crear un

nodo deben de ser guardado temporalmente hasta que se cree el mismo.

Otra de las razones de crear la base de datos SQLite es que la herramienta solo gestionará

los objetos creados por la misma aplicación, pues todos estarán registrados en la base de

datos. Por otra parte la aplicación no dependerá de los servicios web para mostrar los

objetos creados en los set de replicación.

Es preciso aclarar que cuando se crean objetos en la aplicación sin haber creado un nodo,

estos son almacenados en la base de dato SQLite y en el momento que de crea un nodo este

se convierte en el nodo registrador del set al que pertenece nodo. Automáticamente se hace

una carga de toda la configuración del set para la base de datos asociada al nodo creado. Si

se crea algún objeto después de creado el nodo, este último es almacenado en la base de

datos SQLite y en la base de dato del nodo registrado. Si se crea algún nodo después de

estar creado el nodo registrador en el set, este es registrado como nodo hijo al nodo

CAPÍTULO II


54

registrador del set al que pertenece el nuevo nodo y la configuración del nodo hijo es

enviada automáticamente desde el nodo registrador.

A continuación se muestra el diagrama de la base de datos (SQLite) de la aplicación web en

Python:

Figura 8: Modelo físico de datos de la aplicación web

Cabe destacar en este diagrama que cada tabla posee una llave primaria auto-incremental.

En este diagrama están representados todos los objetos que se gestiona en la aplicación y

las relaciones entre los objetos a través de la restricción de llave foránea.

CAPÍTULO II


55

Como se mencionaba anteriormente para su configuración SymmetricDS utiliza las tablas

de metadatos generadas en las bases de datos implicadas en la réplica. El diseño de estas

tabla está orientado a almacenar todo los componentes de de mecanismos así como

registrar toda la actividad que se realiza en el funcionamiento del mecanismo. A

continuación se muestra un diagrama con las principales tablas que almacenan los

componentes de SymmetricDS.

Figura 9: Modelo físico de las tablas de metadato del mecanismo SymmetricDS

CAPÍTULO II


56

Como se observa en la figura 9 las tablas no tienen restricciones de integridad pues no

poseen llaves foráneas, a pesar de que conceptualmente si existen relaciones entre las

tablas, esto es debido a que todos los gestores que soporta el mecanismo no cuentan con

esta característica. En esta figura se resaltan resaltados los campos obligatorios en cada

tabla y puede observase que las llaves primarias de cada tabla quedan bien definidas.

2.8. Conclusiones del capítulo

En este capítulo se presentó el modelo de arquitectura de la herramienta de administración

para SymmetricDS. Se expusieron los conceptos y objetos utilizados para la creación de las

aplicaciones y se describen las principales funcionalidades a implementar de a través del

diagrama de Casos de Uso del Sistema, describiéndose los más significativos.

También se detallan los diagramas de clases que intervienen en la aplicación web de

Django y en el servicio web, quedando descritas cada una de las clases.

Por otra parte se representa el modelo de la base dato en SQLite utilizado en la aplicación

web de Django, destacándose las principales tablas generadas por el mecanismo de

replicación para la configuración de SymmetricDS, así como el mecanismo de

comunicación entre las clases que intervienen en la ejecución de los casos de uso Crear

nodo y Eliminar nodo mediante los diagramas de secuencias.

CAPÍTULO III

Implementación y manual de usuario

57

CAPÍTULO III: Implementación y manual de usuario

La implementación de un sistema es el momento donde se concreta lo planificado durante

la etapa de diseño del software. Se logra como resultado un producto listo para probar y

poner en práctica las funcionalidades que brinda el sistema.

Una interfaz amigable e intuitiva puede influir en la aceptación de un producto, aunque

para un usuario principiante con poco conocimiento sobre una herramienta le resulta

chocante dominar todas las funcionalidades que esta brinda a pesar de contar con interfaces

amigables. Un manual de usuario es la solución a estos problemas, brindando un listado

con las funcionalidades que posee la herramienta y una breve explicación de cada una.

Por ello el propósito de este capítulo es documentar la etapa de desarrollo de la herramienta

además de mostrar un manual de usuario para su consulta.

3.1. Implementación

La herramienta de administración para SymmetricDS consta de dos aplicaciones: una

aplicación web y un servicio web, que interactúan entre sí para lograr un propósito

específico: satisfacer las peticiones del usuario final.

3.1.1. Diagrama de Componentes

Un diagrama de componentes representa la separación de un sistema de software en

componentes físicos (por ejemplo archivos, cabeceras, módulos, paquetes, etc.) y muestra

las dependencias entre estos componentes.

A continuación se muestra los diagramas de componentes del caso de uso Gestionar Nodo

CAPÍTULO III


58

Figura 10: Diagrama de componentes para el caso de uso Gestionar Nodo

El diagrama representado en la figura 10 muestra las relaciones entre los ficheros

involucrados en el caso de uso antes mencionado. Django hace uso del patrón

arquitectónico Modelo – Vista – Controlador, que queda representado en tres ficheros

(urls.py,views.py y models.py).

A continuación se detallan cada uno de los componentes que se representan en la figura 10.

Componente urls.py: fichero generado por Django, que cumple el rol de

controlador, pues en él se define todas las urls disponibles en el proyecto.

Componente views.py: fichero generado por Django. Existe un fichero de este tipo

por cada aplicación que se cree en el proyecto. El propósito del mismo es contener

todas las vistas de la aplicación a la que pertenece, mostrándole al usuario las

interfaces del proyecto.

Componente extBase.html: es la plantilla de la herramienta, su tarea principal es

incluir los ficheros Java Script y CSS necesarios para generar las interfaces de

usuarios.

CAPÍTULO III


59

Paquete Extjs: este paquete tiene incluido la biblioteca JavaScript ExtJS empleada

en el desarrollo de la herramienta para el diseño de las interfaces de usuario.

Componente base.js: en este fichero se encuentra implementada la interfaz principal

de la de la herramienta, tomándose como plantilla para la creación de las vistas.

Componente nodoManager.js: este fichero contiene la implementación de las

funciones JavaScript necesarias para visualizar las interfaces de usuario del caso de

uso Gestionar Nodo.

Componente nodoManager.py: contiene una clase controladora para gestionar

todas las acciones referentes a un nodo dentro de la herramienta.

Componente models.py: fichero generado en cada aplicación del proyecto Django

Su objetivo es definir las clases del modelo para la interacción con la base de dato

de la herramienta.

Componente metadata.db: es una base de dato en SQLite para almacenar

información persistente de la herramienta.

Componente clientWebService.py: este fichero contiene una clase para el acceso y

ejecución de métodos de un servicio web, la misma se auxilia de la librería SUDS

para lograr este propósito.

Paquete Servicio web: este paquete es un servicio web desarrollado en Java con el

fin de administrar las configuraciones y las instancias SymmetricDS creadas en un

servidor Tomcat. En el mismo existen un conjunto de componentes con la

implementación de las clases necesarias para cumplir este propósito explicadas en

el capítulo anterior. Ver figura 11

CAPÍTULO III


60

Figura 11: Componentes del paquete Servicio web implicados en el caso de uso Gestionar Nodo

3.1.2. Paquetes de las aplicaciones

Para una mayor organización en la programación de la herramienta se crearon diferentes

paquetes con un propósito determinado.

En la aplicación web desarrollada en el framework Django se crearon dos aplicaciones:

commun: paquete que define todos los ficheros relacionado con la interfaz

principal, además contiene la implementación de un grupo de componentes con un

fin común. Dentro de los cuales se encuentra el árbol explorador, la barra de

herramientas, la página principal entro otros.

appreply: Este paquete contiene los ficheros para el trabajo con los objetos del

mecanismo de replicación

CAPÍTULO III


61

El servicio web tiene una estructura de paquetes que agrupa las clases según sus

funcionalidades:

utils: este paquete agrupa un conjunto de clases auxiliares que facilitan la

implementación del servicio, como el fichero de propiedades de SymmetricDS, la

ejecución de comandos SHELL entre otros.

symm_obj_manager: paquete que contiene las clases controladoras de los objetos

de SymmetricDS, el trabajo con las conexiones a las bases de datos implicadas en la

réplica, etc.

symm_db: paquete que contiene las clases del domino utilizadas por el ORM

Hibernarte para el mapeo con las tablas de las bases de datos.

symmetricds: este paquete consta de una clase controladora con la implementación

de todas las funcionalidades del servicio web, y otra clase donde se define los

métodos del servicio web a consultar.

3.1.3. Diagrama de Despliegue

Un diagrama de despliegue es un grafo de nodos unidos por conexiones de comunicación,

que muestra las relaciones físicas entre los componentes hardware y software en el sistema

final, es decir, la configuración de los elementos de procesamiento en tiempo de ejecución

y los componentes software.

Figura 12: Diagrama de despliegue de la herramienta

CAPÍTULO III


62

A continuación se realiza una breve descripción del diagrama de despliegue representado

en la figura 12:

Servidor web: En este nodo estará montada la aplicación sobre el servidor web

Apache. La cual se comunica con el servicio web a través del protocolo

<<SOAP>>.

Servicio web: Sobre este nodo estará configurado un servicio web en java, el cual

correrá sobre un servidor Tomcat y utilizará Axis2 para su publicación. Este se

comunica con el nodo Servidor de Base de Datos Réplica a través del drive

<<JDBC>>.

Servidor de BD: Este nodo representa los gestores de bases de datos implicados en

la réplica.

PC Cliente: Desde este nodo los usuarios podrán acceder a la aplicación a través de

un navegador ya sea Internet Explorer o Firefox, haciendo uso del protocolo

<<HTTP>>.

3.2. Manual de Usuario

La interfaz principal del sistema puede observarse en la figura 13 y está estructurada de la

siguiente forma:

Cabecera: se muestra el nombre de la aplicación y el botón Ayuda en la parte

derecha.

Componentes: se muestra el Explorador para acceder al árbol de componentes.

Área de trabajo: contiene el menú principal y breve descripción de SymmetricDS.

Pie de página: se muestran los datos de registro de la aplicación y los temas Acerca

de y Créditos.

CAPÍTULO III


63

Figura 13: Interfaz principal de la aplicación.

3.2.1. Estructura de la interfaz principal

A continuación se realiza una breve explicación de las partes principales de la aplicación.

3.2.1.1. Componentes

El Explorador contiene un árbol de componentes que está dividido en Servicios y Sets.

Como se muestra en la figura 14, los sets poseen varios componentes entre los que se

encuentran:

Grupos, que incluye a los Nodos.

Vínculos de grupos

Canales

Disparadores

Ruters

Ruters–Disparadores

CAPÍTULO III


64

Figura 14: Árbol de componentes en el Explorador.

Cada componente tiene la opción de ser creado, editado y eliminado. Para acceder a las dos

últimas opciones se debe dar clic derecho sobre el componente en particular, como se

muestra en la figura 15.

CAPÍTULO III


65

Figura 15: Clic derecho para la opción de Editar y Eliminar componentes.

De igual manera para crear un componente se debe hacer clic derecho sobre el componente

padre, como se muestra en la figura 16 para el caso de los componentes incluidos dentro de

un set.

CAPÍTULO III


66

Figura 16: Clic derecho para la opción de Crear componentes.

3.2.1.2. Área de trabajo

En la parte superior del área de trabajo se encuentra el menú principal fragmentado en:

Set replicación, como se muestra en la figura 17, contiene el submenú para Crear,

Editar y Eliminar un set, siempre que para estas dos últimas opciones esté

previamente seleccionado en el árbol de componentes un set en particular y de

forma separada aparece un submenú que permite de igual forma crear ya sea un

Grupo, Vínculo o Canal. Con un set seleccionado en el árbol, se puede editar y/o

eliminar los componentes mencionados anteriormente siempre que se haya marcado

en el árbol el componente sobre cual realizar alguna de estas acciones.

CAPÍTULO III


67

Figura 17: Submenú Set replicación.

Servicio de administración, como se muestra en la figura 18, contiene el submenú

para Crear, Editar y Eliminar un servicio. Para las dos últimas opciones debe estar

seleccionado un servicio en el árbol de componentes. Para crear un servicio solo se

debe hacer clic sobre esta opción.

Figura 18: Submenú Servicio de administración.

Nodos, como se muestra en la figura 19, contiene el submenú para Crear, Editar y

Eliminar un nodo y de forma separada para determinar el Estado del nodo. Para las

tres últimas opciones debe estar seleccionado un nodo en el árbol de componentes.

Para crear un nodo debe estar seleccionado el grupo sobre el cuál realizar esta

acción.

CAPÍTULO III


68

Figura 19: Submenú Nodos.

Disparadores, como se muestra en la figura 20, contiene el submenú para Crear,

Editar y Eliminar un disparador, siempre que para estas dos últimas opciones esté

previamente seleccionado en el árbol de componentes un disparador en particular y

para crear debe estar seleccionado el set sobre el cual se realizará esta acción. De

forma separada aparece un submenú que permite de igual forma crear ya sea un

Ruters o un Ruters – Disparador con un set seleccionado en el árbol o editar y

eliminar los componentes mencionados anteriormente siempre que se haya marcado

en el árbol el componentes sobre cuál realizar alguna de estas acciones.

Figura 20: Submenú Disparadores.

3.2.2. Interfaces de usuario de los componentes

Con el objetivo de permitirle al usuario una fácil interacción con la aplicación se han

diseñado las interfaces con varios componentes en común, como se describen a

continuación:

CAPÍTULO III


69

Botón Cerrar ( ): permite cerrar cualquier ventana, se hayan o no introducido

datos.

Botón Aceptar ( ): permite guardar los datos introducidos por el usuario

y mostrar cualquier validación referente a estos datos.

Botón Cancelar ( ): permite cancelar los datos introducidos por el

usuario y cierra la ventana.

3.2.2.1. Interfaces de usuario para los sets.

Para Crear un set, se debe hacer clic en la opción Crear del submenú Set replicación o

haciendo clic derecho sobre el componente padre Sets en el árbol del Explorador,

mostrándose la interfaz de la figura 21.

Figura 21: Interfaz de usuario Crear set de replicación.

Los datos a llenar para crear un nuevo set son:

Nombre: que debe ser escrito de forma obligatoria.

Descripción: puede ser escrito de forma opcional.

Una vez llenados los campos, se hace clic en el botón Aceptar, para completar la adición

del nuevo set.

CAPÍTULO III


70

Para Editar un set, se debe hacer clic en la opción Editar del submenú Set replicación

habiendo seleccionado previamente en el árbol de componentes un set en particular o

haciendo clic derecho sobre el set deseado en el árbol del Explorador. La interfaz que se

muestra es igual a la interfaz de la figura 21 pero con los datos que posee el set

seleccionado.

Para Eliminar un set, se debe hacer clic en la opción Eliminar del submenú Set replicación

habiendo seleccionado previamente en el árbol de componentes un set en particular o

haciendo clic derecho sobre el set deseado en el árbol del Explorador. Para completar esta

acción aparece un mensaje de aviso donde se debe seleccionar la opción Si o No.

3.2.2.2. Interfaces de usuario para los servicios.

Para Crear un servicio, se debe hacer clic en la opción Crear del submenú Servicio de

administración o haciendo clic derecho sobre el componente padre Servicios en el árbol del

Explorador, mostrándose la interfaz de la figura 22.

Figura 22: Interfaz de usuario Crear servicio de administración.

Los datos a llenar para crear un nuevo servicio son:

Nombre

Host: el nombre o el IP del servicio web.

Puerto: el puerto que usa el servicio, para el cual solo se permiten números.

CAPÍTULO III


71

Una vez llenados todos los campos de forma obligatoria, se hace clic en el botón Aceptar,

para completar la adición del nuevo servicio.

Para Editar un servicio, se debe hacer clic en la opción Editar del submenú Servicio de

administración habiendo seleccionado previamente en el árbol de componentes un servicio

en particular o haciendo clic derecho sobre el servicio deseado en el árbol del Explorador.

La interfaz que se muestra es igual a la interfaz de la figura 22 pero con los datos que

posee el servicio seleccionado.

Para Eliminar un servicio, se debe hacer clic en la opción Eliminar del submenú Servicio

de administración habiendo seleccionado previamente en el árbol de componentes un

servicio en particular o haciendo clic derecho sobre el servicio deseado en el árbol del

Explorador. Para completar esta acción aparece un mensaje de aviso donde se debe

seleccionar la opción Si o No.

3.2.2.3. Interfaces de usuario para los grupos.

Para Crear un grupo, se debe hacer clic en la opción Crear del apartado Grupo en el

submenú Set replicación habiendo seleccionado previamente en el árbol de componentes

un set en particular o haciendo clic derecho sobre el set donde se quiere crear en el árbol

del Explorador y dentro de este seleccionar Crear componente y elegir Grupo,


Figura 23: Interfaz de usuario Crear grupo de replicación.

CAPÍTULO III


72

Los datos a llenar para crear un nuevo grupo son:

Nombre: que debe ser escrito de forma obligatoria.

Descripción: puede ser escrito de forma opcional.

Una vez llenados todos los campos de forma obligatoria, se hace clic en el botón Aceptar,

para completar la adición del nuevo grupo.

Para Editar un grupo, se debe hacer clic en la opción Editar del apartado Grupo en el


un grupo en particular o haciendo clic derecho sobre el grupo deseado en el árbol del

Explorador. La interfaz que se muestra es igual a la interfaz de la figura 23 pero con los

datos que posee el grupo seleccionado.

Para Eliminar un grupo, se debe hacer clic en la opción Eliminar del apartado Grupo en el


un grupo en particular o haciendo clic derecho sobre el grupo deseado en el árbol del



3.2.2.4. Interfaces de usuario para los nodos.

Para Crear un nodo, se debe hacer clic en la opción Crear en el submenú Nodos habiendo

seleccionado previamente en el árbol de componentes un grupo en particular o haciendo

clic derecho sobre el grupo donde se quiere crear en el árbol del Explorador y dentro de

este seleccionar Crear nodo, mostrándose la interfaz de la figura 24.

CAPÍTULO III


73

Figura 24: Interfaz de usuario Crear nodo.

Los datos a llenar para crear un nuevo nodo son:

Nombre: dato obligatorio.

Servicio: debe existir un servicio creado con anterioridad. Dato obligatorio.

Gestor: se debe seleccionar un gestor, entre los que se encuentran: MySql, Oracle,

PostgreSQL y SQLServer. Dato obligatorio.

Host: el nombre o el IP del nodo. Dato obligatorio.

Nombre BD: nombre de la base de datos. Dato obligatorio.

Puerto: el puerto que usa el nodo, para el cual solo se permiten números. Dato

obligatorio.

Usuario: usuario para conectarse a la base de datos. Dato obligatorio.

Clave: contraseña del usuario. Dato obligatorio.


del nuevo nodo.

CAPÍTULO III


74

Para Editar nodo, se debe hacer clic en la opción Editar en el submenú Nodos habiendo

seleccionado previamente en el árbol de componentes un nodo en particular o haciendo clic

derecho sobre el nodo deseado en el árbol del Explorador. La interfaz que se muestra es

igual a la interfaz de la figura 24 pero con los datos que posee el nodo seleccionado.

Para Eliminar un nodo, se debe hacer clic en la opción Eliminar en el submenú Nodos

habiendo seleccionado previamente en el árbol de componentes un nodo en particular o

haciendo clic derecho sobre el nodo deseado en el árbol del Explorador. Para completar

esta acción aparece un mensaje de aviso donde se debe seleccionar la opción Si o No.

Para verificar el Estado del nodo, se debe hacer clic en la opción Estado del nodo en el

submenú Nodos habiendo seleccionado previamente en el árbol de componentes un nodo

en particular o haciendo clic derecho sobre el nodo deseado en el árbol del Explorador,


Figura 25: Interfaz de usuario Nodos.

CAPÍTULO III


75

Con esta interfaz se puede manipular el nodo y verificar el estado en que se

encuentra, pues se muestra en la parte superior de la interfaz.

Para iniciar el nodo se debe hacer clic en el botón Iniciar ( ).

Para detener el nodo se debe hacer clic en el botón Detener (

).

Para reiniciar el nodo se debe hacer clic en el botón Reiniciar (

).

En esta interfaz se pueden manipular tantos nodos como el usuario tenga registrado

pues se van agregando uno seguido del otro. Para mayor facilidad a los usuarios se

ubicaron tres botones en la parte superior que realizan las siguientes opciones:

Actualizar ( ).

Cerrar ( ).

Minimizar ( ).

Maximizar ( ).

3.2.2.5. Interfaces de usuario para los vínculos entre grupos.

Para Crear un vínculo entre grupos, se debe hacer clic en la opción Crear del apartado

Vínculo en el submenú Set replicación habiendo seleccionado previamente en el árbol de

componentes un set en particular o haciendo clic derecho sobre el set donde se quiere crear

en el árbol del Explorador y dentro de este seleccionar Crear componente y elegir Vínculo,


CAPÍTULO III


76

Figura 26: Interfaz de usuario Crear vínculo entre grupos.

Los datos a llenar para crear un nuevo vínculo son:

Grupo origen: se elige uno de los grupos que aparece en el selector de forma

obligatoria.

Grupo destino: se elige uno de los grupos que aparece en el selector distinto del

grupo origen de forma obligatoria.

Evento: se elige entre los eventos Push y Pull de forma obligatoria.

Una vez llenados todos los campos, se hace clic en el botón Aceptar, para completar la

adición del nuevo vínculo.

Para Editar un vínculo entre grupos, se debe hacer clic en la opción Editar del apartado

Vínculo en el submenú Set replicación habiendo seleccionado previamente en el árbol de

componentes un vínculo en particular o haciendo clic derecho sobre el vínculo deseado en

el árbol del Explorador. La interfaz que se muestra es igual a la interfaz de la figura 26

pero con los datos que posee el vínculo seleccionado.

Para Eliminar un grupo, se debe hacer clic en la opción Eliminar del apartado Vínculo en

el submenú Set replicación habiendo seleccionado previamente en el árbol de componentes

un vínculo en particular o haciendo clic derecho sobre el vínculo deseado en el árbol del



CAPÍTULO III


77

3.2.2.6. Interfaces de usuario para los canales.

Para Crear un canal, se debe hacer clic en la opción Crear del apartado Canal en el


un set en particular o haciendo clic derecho sobre el set donde se quiere crear en el árbol

del Explorador y dentro de este seleccionar Crear componente y elegir Canal, mostrándose

la interfaz de la figura 27.

Figura 27: Interfaz de usuario Crear canal de replicación.

Los datos a llenar para crear un nuevo canal son:


Orden de procesamiento: prioridad que tendrá un disparador en comparación con

otro. Dato obligatorio.

Tamaño máximo: tamaño de los datos a capturar. Dato obligatorio.

Tamaño de envío: tamaño de los a enviar. Dato obligatorio.

Máximos datos a enrutar. Dato obligatorio.

Período de extracción. Dato obligatorio.

CAPÍTULO III


78

Grupo de selección: incluye las opciones Activo, Enrutar datos antiguos y Enrutar

datos o filas. Dato obligatorio.

Algoritmo: se debe seleccionar que algoritmo tendrá el disparador, que puede ser:

default, nontransactional y transactional. Dato obligatorio.

Descripción: es un dato opcional.


del nuevo canal.

Para Editar un canal, se debe hacer clic en la opción Editar del apartado Canal en el


un canal en particular o haciendo clic derecho sobre el canal deseado en el árbol del


datos que posee el canal seleccionado.

Para Eliminar un canal, se debe hacer clic en la opción Eliminar del apartado Canal en el


un canal en particular o haciendo clic derecho sobre el canal deseado en el árbol del



3.2.2.7. Interfaces de usuario para los disparadores.

Para Crear un disparador, se debe hacer clic en la opción Crear en el submenú

Disparadores habiendo seleccionado previamente en el árbol de componentes un set en

particular o haciendo clic derecho sobre el set donde se quiere crear en el árbol del

Explorador y dentro de este seleccionar Crear componente y elegir Disparador,


CAPÍTULO III


79

Figura 28: Interfaz de usuario Crear disparador.

Los datos a llenar para crear un nuevo disparador son:


Canal: debe existir un canal creado con anterioridad. Dato obligatorio.

Nodo: debe existir un nodo creado con anterioridad. Dato obligatorio.

Tabla origen: tabla de donde se capturan los datos a replicar. Dato obligatorio.

Opciones avanzadas: se muestran las columnas a replicar y las columnas que no se

replicarán. Dato obligatorio.

Sincronizar al: grupo de selección que indica si se replicarán al Actualizar, Insertar

o Eliminar. Dato obligatorio.


del nuevo disparador.

CAPÍTULO III


80

Para Editar un disparador, se debe hacer clic en la opción Editar en el submenú

Disparador habiendo seleccionado previamente en el árbol de componentes un disparador

en particular o haciendo clic derecho sobre el disparador deseado en el árbol del


datos que posee el disparador seleccionado.

Para Eliminar un canal, se debe hacer clic en la opción Eliminar en el submenú

Disparador habiendo seleccionado previamente en el árbol de componentes un disparador

en particular o haciendo clic derecho sobre el disparador deseado en el árbol del



3.2.2.8. Interfaces de usuario para los ruters.

Para Crear un ruter, se debe hacer clic en la opción Crear del apartado Ruters en el

submenú Disparador habiendo seleccionado previamente en el árbol de componentes un

set en particular o haciendo clic derecho sobre el set donde se quiere crear en el árbol del

Explorador y dentro de este seleccionar Crear componente y elegir Ruter, mostrándose la

interfaz de la figura 29.

Figura 29: Interfaz de usuario Crear ruter.

CAPÍTULO III


81

Los datos a llenar para crear un nuevo ruter son:


Grupo origen: se elige uno de los grupos que aparece en el selector. Dato

obligatorio.

Grupo destino: se elige uno de los grupos que aparece en el selector distinto del

grupo origen. Dato obligatorio.

Tabla destino: tabla que recibe los datos replicados.

Sincronizar al: grupo de selección que indica si se replicarán al Actualizar, Insertar

o Eliminar. Dato obligatorio.


del nuevo ruter.

Para Editar un ruter, se debe hacer clic en la opción Editar del apartado Ruters en el

submenú Disparadores habiendo seleccionado previamente en el árbol de componentes un

ruter en particular o haciendo clic derecho sobre el ruter deseado en el árbol del


datos que posee el ruter seleccionado.

Para Eliminar un ruter, se debe hacer clic en la opción Eliminar del apartado Ruters en el

submenú Disparadores habiendo seleccionado previamente en el árbol de componentes un

ruter en particular o haciendo clic derecho sobre el ruter deseado en el árbol del



3.2.2.9. Interfaces de usuario para los ruters - disparadores.

Para Crear un ruter - disparador, se debe hacer clic en la opción Crear del apartado

Ruters-Disparadores en el submenú Disparadores habiendo seleccionado previamente en

el árbol de componentes un set en particular o haciendo clic derecho sobre el set donde se

quiere crear en el árbol del Explorador y dentro de este seleccionar Crear componente y

elegir Ruter-disparador, mostrándose la interfaz de la figura 30.

CAPÍTULO III


82

Figura 30: Interfaz de usuario Crear ruter - disparador.

Los datos a llenar para crear un nuevo ruter-disparador son:

Disparador: debe estar previamente creado. Dato obligatorio.

Ruter: debe estar previamente creado. Dato obligatorio.

Orden cargar datos: número que indica la prioridad para cargar los datos. Dato

obligatorio.


del nuevo ruter-disparador.

Para Editar un ruter - disparador, se debe hacer clic en la opción Editar del apartado


el árbol de componentes un ruter-disparador en particular o haciendo clic derecho sobre el

ruter-disparador deseado en el árbol del Explorador. La interfaz que se muestra es igual a

la interfaz de la figura 30 pero con los datos que posee el ruter-disparador seleccionado.

Para Eliminar un ruter - disparador, se debe hacer clic en la opción Eliminar del apartado


el árbol de componentes un ruter-disparador en particular o haciendo clic derecho sobre el

ruter-disparador deseado en el árbol del Explorador. Para completar esta acción aparece un

mensaje de aviso donde se debe seleccionar la opción Si o No.

CAPÍTULO III


83

3.2.3. Visualización de datos:

La vista de datos o dataview proporciona a los usuarios una fácil navegación por la

aplicación y la visualización de las propiedades de los componentes. Para acceder a esta

vista solo se debe hacer doble clic sobre cualquiera de los componentes que parecen en el

árbol del Explorador. Como se muestra en la figura 31 la interfaz se subdivide en:

Contenido: donde se muestra los componentes incluidos dentro del que fue cliqueado. De

igual forma con un doble clic realizado a cualquiera de estos componentes se puede

acceder a sus hijos.

Propiedades: donde se muestra en una tabla dinámica las propiedades del elemento

seleccionado.

Figura 31: interfaz de usuario de la Vista de Datos.

CAPÍTULO III


84

3.3. Conclusiones del capítulo

En este capítulo se presentó el diagrama de componentes del CU Gestionar Nodo dado la

complejidad que esté presenta, quedando reflejadas las clases del diseño en ficheros reales

con sus respectivas dependencias.

También se detalla el diagrama de despliegue que servirá de apoyo para la implantación del

sistema, proponiéndose dos variantes para esta actividad.

Con el objetivo de facilitar la interacción de los usuarios con la herramienta, se realiza una

descripción de las funcionalidades de la misma a través de un manual de usuario.

CONCLUSIONES

85

CONCLUSIONES

Como resultado de la investigación se propuso la creación una herramienta de

administración para el mecanismo de replicación de datos SymmetricDS. Concluyéndose

que:

Al caracterizar los mecanismos de replicación de datos de software libre se

seleccionó a SymmetricDS como el más adecuado para ser utilizado en Cuba. Esta

conclusión se basa en las características que presenta en cuanto a: asincronismo,

replicación lógica, heterogeneidad, multiplataforma así como la capacidad de

replicar datos entre redes WAN si necesidad del montaje de sistemas VPN en las

redes origen y destino.

Se definieron y fundamentaron las tecnologías de software libre apropiadas para

crear una aplicación que permita administrar SymmetricDS orientado a la web 2.0.

Se diseñaron los diagramas UML y otros necesarios para representar las

aplicaciones de la solución propuesta.

Se implementó una herramienta administrativa para el mecanismo de replicación

SymmetricDS sobre la web 2.0, incluyendo un Manual de Usuario explicando las

funcionalidades de la herramienta.

RECOMENDACIONES

86

RECOMENDACIONES

Una vez concluido este trabajo, se recomienda:

Realizar pruebas al sistema durante un período, comprobando que cumpla con las

funcionalidades propuestas.

Desarrollarle un módulo de seguridad garantizando con ello la integridad y

resguardo de la información que se maneje.

Continuar la investigación con el propósito de aumentar las funcionalidades de la

herramienta, obteniendo mejoras en futuras versiones de la misma.

REFERENCIAS BIBLIOGRÁFICAS

87

REFERENCIAS BIBLIOGRÁFICAS

Batista Soler, O., & Rodríguez Figueredo, H, 2006. Análisis Jurídico del software libre.

Sus particularidades en Cuba.

Django Software Foundation, 2010. Django web framework | Django en Español, django-

es. ¡Descubre Django! Available at: http://django.es/ [Accedido Noviembre 11,

2010].

Javier Eguíluz Pérez, 2009. Introducción a CSS. Available at:

http://www.librosweb.es/css/pdf/introduccion_css.pdf.

Javier Eguíluz Pérez, 2008. Introducción a XHTML. Available at:

http://www.librosweb.es/xhtml/pdf/introduccion_xhtml.pdf.

JumpMind, Inc, 2007. SymmetricDS - SymmetricDS. Overview. Available at:

http://symmetricds.codehaus.org/ [Accedido Abril 5, 2011].

Mariano Reingart, 2009. PgFoundry: PyReplica: Información del Proyecto. PyReplica.

Available at: http://pgfoundry.org/projects/pyreplica/ [Accedido Abril 6, 2011].

Microsoft Corporation, 2011. Microsoft SQL Server 2008 R2 | Database Management

System. Microsoft SQL Server 2008 R2. Available at:

http://www.microsoft.com/sqlserver/en/us/default.aspx [Accedido Abril 6, 2011].

Miguel Angel Alvarez, 2003. Qué es Python. Lenguaje de programación de propósito

general, orientado a objetos, que también puede utilizarse para el desarrollo web.

Available at: http://www.desarrolloweb.com/articulos/1325.php [Accedido

Noviembre 11, 2010].

Oracle Corporation, 2011. Oracle | Hardware and Software, Engineered to Work Together.

ORACLE. Available at: http://www.oracle.com/index.html [Accedido Abril 6,

2011].

PostgreSQL Global Development Group, 1996. PostgreSQL: About. About. Available at:

http://www.postgresql.org/about/ [Accedido Noviembre 11, 2010].

Raúl Monge, 2005. Sistemas Distribuidos de Computación

Trabajo de Investigación,

Slony Development Group, 2007. Slony-I. Slony-I. Available at: http://www.slony.info/

[Accedido Abril 5, 2011].

BIBLIOGRAFÍA

88

BIBLIOGRAFÍA

Apache Software Foundation, 1999. Apache Tomcat - Welcome! Apache Tomcat.

Available at: http://tomcat.apache.org/ [Accedido Abril 5, 2011].

Brian J. Tilma, 2008. DBReplicator API Reference | DBReplicator. DBReplicator.

Available at: http://dbreplicator.org/DBReplicatorAPI/index.html [Accedido Abril

5, 2011].

Cybertec, 2011. About « Cybertec PostgreSQL Pros' Blog & Archives. CYBERTEC.

Available at: http://www.cybertec.at/en/ [Accedido Abril 5, 2011].

Django Software Foundation, 2005. Django | The web framework for perfectionists with

deadlines. Meet Django. Available at: http://www.djangoproject.com/ [Accedido


hibernate team, 2011. Hibernate - JBoss Community. hibernate. Available at:

http://www.hibernate.org/ [Accedido Abril 5, 2011].

Jairo Chapela Mart´ınez, 2007. Introducción al entorno de desarrollo Eclipse. Available at:

http://www-gris.det.uvigo.es/wiki/pub/Main/MiscResources/Manual_Eclipse.pdf.

Javier Eguíluz Pérez, 2009a. Introducción a CSS. Available at:

http://www.librosweb.es/css/pdf/introduccion_css.pdf.

Javier Eguíluz Pérez, 2009b. Introducción a JavaScript. Available at:

http://www.librosweb.es/javascript/pdf/introduccion_javascript.pdf.

Javier Eguíluz Pérez, 2008. Introducción a XHTML. Available at:

http://www.librosweb.es/xhtml/pdf/introduccion_xhtml.pdf.

Jesús Manuel Montero Garrido, 2010. Plataforma Eclipse Introducción Técnica. Available

at:

http://150.244.56.228/descargas_web/cursos_verano/20040801/Jesus_Montero/doc

umentacion_eclipse.pdf.

JumpMind, Inc, 2007. SymmetricDS - SymmetricDS. Overview. Available at:

http://symmetricds.codehaus.org/ [Accedido Abril 5, 2011].

Mariano Reingart, 2009. PgFoundry: PyReplica: Información del Proyecto. PyReplica.

Available at: http://pgfoundry.org/projects/pyreplica/ [Accedido Abril 6, 2011].

Microsoft Corporation, 2011. Microsoft SQL Server 2008 R2 | Database Management

System. Microsoft SQL Server 2008 R2. Available at:

http://www.microsoft.com/sqlserver/en/us/default.aspx [Accedido Abril 6, 2011].

BIBLIOGRAFÍA

89

Miguel Angel Alvarez, 2003. Qué es Python. Lenguaje de programación de propósito

general, orientado a objetos, que también puede utilizarse para el desarrollo web.

Available at: http://www.desarrolloweb.com/articulos/1325.php [Accedido


Oracle Corporation, 2011. Oracle | Hardware and Software, Engineered to Work Together.

ORACLE. Available at: http://www.oracle.com/index.html [Accedido Abril 6,

2011].

PgCLuster team, 2011. PGCluster top page. PgCLuster. Available at:

http://pgcluster.projects.postgresql.org/ [Accedido Abril 5, 2011].

PostgreSQL Global Development Group, 1996. PostgreSQL: The world's most advanced

open source database. PostgreSQL. Available at: http://www.postgresql.org/


Rafael Martinez, 2009. Hot Standby y Streaming replication | www.postgresql.org.es. Hot

Standby y Streaming replication. Available at:

http://www.postgresql.org.es/node/483 [Accedido Abril 5, 2011].

Raúl Monge, 2005. Sistemas Distribuidos de Computación

Trabajo de Investigación,

Sencha Inc., 2006. Sencha - Ext JS - Client-side JavaScript Framework. Ext JS Cross-

Browser Rich Internet Application Framework. Available at:

http://www.sencha.com/products/js/ [Accedido Noviembre 11, 2010].

Slony Development Group, 2007. Slony-I. Slony-I. Available at: http://www.slony.info/


SUDS team, 2011. suds - Trac. SUDS. Available at: https://fedorahosted.org/suds/


The Apache Software Foundation, 2011. Welcome to The Apache Software Foundation!

The Apache Software Foundation. Available at: http://www.apache.org/ [Accedido

Abril 5, 2011].

The Apache Software Foundation., 2004. Apache Axis2 - Apache Axis2/Java - Next

Generation web Services. Welcome to Apache Axis2/Java. Available at:

http://axis.apache.org/axis2/java/core/ [Accedido Abril 5, 2011].

Tomás Javier Robles Prado & Raúl Turienzo Fernández, Introducción a PostgreSQL.

Available at: http://users.servicios.retecal.es/tjavier/intdb.pdf.

Visual Paradigm, 2010. UML CASE tool for software development. Visual Paradigm for

UML - UML tool for software application development. Available at:

http://www.visual-paradigm.com/product/vpuml/ [Accedido Noviembre 11, 2010].

Título: Herramienta administrativa para mecanismo de ...

Documents

Transcript of Título: Herramienta administrativa para mecanismo de ...