Estructura per a servidors de serveis a xarxes IRC

Estructura per a servidors de serveis a xarxes IRC
AUTOR: Rubén Lozano Díaz
DIRECTOR: Carlos Molina Clemente
Adreça electrònica: ruben.lozano@estudiants.urv.cat
Resum: El present projecte s’encarrega de construir una estructura sòlida que permetria
que un servidor, principalment sobre xarxes IRC, reculli i serveixi peticions d’usuaris
registrats a una base de dades. Tres son les unitats principals que entren en joc en
aquesta infraestructura: usuaris, servidor i base de dades. Als usuaris els anomenarem
serveis, aquests serveis podran conectar-se a aquest servidor per a que executi les
peticions que faran. Aquestes peticions seran validades i nomes els serveis que tinguin
els permisos adients podran executar les peticions que es demanin. El servidor no
només constarà de processament de rutines sinó que també podrà estar a l’escolta de
donats esdeveniments de xarxa als que un usuari mai podrà tenir accés per si mateix.
Aquesta escolta serà realitzada per un patró de disseny observer amb una connexió
remota asíncrona per xml-rpc, el mateix tipus de connexió que realitzen els serveis al
servidor però al sentit oposat. La base de dades associada al servidor serveix per guardar
les dades de validació dels serveis així com els seus permisos. A la base de dades també
estarà creada la estructura bàsica de dades d’una xarxa IRC per poder guardar la
informació que es desitgi. El projecte no només es centra a aquests aspectes tècnics sinó
que té com a pilar central la compatibilitat per poder conectar-se des de qualsevol
plataforma i sota qualsevol llenguatge fent servir un estàndard de connexions per a
rutines remotes. També intenta aproximar l’ús de codi obert; l’única part de software
privatiu del projecte la aporta el servidor Oracle, tot i que gràcies a hibernate i a la
JDBC de Java es possible canviar el tipus de base de dades modificant un número de
paràmetres mínim.
Proyecto fin de carrera
Rubén Lozano Díaz
Resumen: El presente proyecto se encarga de construir una estructura sólida para
permitir que un servidor, principalmente sobre redes IRC, recoja y sirva peticiones de
usuarios registrados en una base de datos. Tres son las unidades principales que entran
en acción en esta infraestructura: usuarios, servidor y base de datos. Los usuarios serán
llamados servicios, estos servicios podrán conectarse a este servidor para que ejecute las
peticiones que realizan. Estas peticiones serán validadas y solo los servicios que tengan
los permisos oportunos podrán ejecutar las rutinas que pidan. El servidor no solo
constará de procesamiento de rutinas sino que también podrá estar a la escucha de
ciertos eventos de red a los que un usuario nunca podrá tener acceso por si mismo. Esta
escucha está realizada por un patrón de diseño observer con conexión remota asíncrona
por xml-rpc, el mismo tipo de conexión que realizan los servicios al servidor pero en el
sentido contrario. La base de datos asociada al servidor sirve para guardar los datos de
validación de los servicios así como sus permisos. En la base de datos también estará
creada la estructura básica de datos de una red IRC para poder guardar la información
que se desee. El proyecto no solo se centra en estos aspectos técnicos sino que tiene
como pilar central la compatibilidad para poder conectarse desde cualquier plataforma y
bajo cualquier lenguaje mediante un estándar en conexiones de procedimientos remotos.
También intenta hacer hincapié en el uso del código abierto; la única parte de software
privativo del proyecto la aporta el servidor Oracle, y de todas formas gracias a
hibernate y a la JDBC de Java es posible cambiar el tipo de base de datos modificando
un número de parámetros mínimo.
Abstract: This project is responsible for building a solid structure to allow a server,
especially on IRC networks, pick and serve user requests in a database. There are three
main units that come into action in the infrastructure: user, server and database. Users
will be called services, these services can connect to this server to run applications that
services want to perform. These petitions will be validated so only those services which
have the appropriate permissions can execute the requested procedures. The server does
not just consist of processing procedures, but may also be listening to certain network
events to which a user can never gain access for himself. An observer design pattern is
implemented in this project for asynchronous remote connection with xml-rpc, the same
type of connection being made by services to the server, but in the opposite direction.
The associated database server used to store the data validation services as well as their
permissions. At database is also created the basic structure of an IRC network data to
save the information anyone wants. The project not only focuses on these points but is
compatible to connect from any platform and in any language through standard remote
connection procedures. It also seeks to emphasize the use of open source though Oracle
is privative software. Anyway using hibernate and JDBC Java we can change the
database by modifying a minimum number of parameters.
Titulació: Enginyera Tècnica en Informàtica de Gestió
Data Presentació: Juny de 2009.
2
Proyecto fin de carrera
Rubén Lozano Díaz
Índice
1. Introducción .................................................................................................... 4
1.1 Internet Relay Chat ................................................................................... 4
1.1.1 Definición ........................................................................................... 4
1.1.2 Servidores .......................................................................................... 7
1.1.3 Redes ................................................................................................. 9
1.1.4 Clientes ............................................................................................ 11
1.1.5 Servicios ........................................................................................... 12
1.1.6 Origen e historia ............................................................................... 13
1.2 Persistencia ............................................................................................ 14
1.2.1 ORACLE .......................................................................................... 15
1.2.2 Hibernate.......................................................................................... 17
1.3 Protocolos de comunicación ................................................................... 19
1.3.1 HTTP ................................................................................................ 20
1.3.2 XML-RPC ......................................................................................... 21
2. Motivación y objetivos del proyecto .............................................................. 23
2.1 Objetivos ................................................................................................. 23
2.2 Motivación ............................................................................................... 24
3. Especificaciones........................................................................................... 26
3.1 Persistencia ............................................................................................ 27
3.2 Comunicación con Redes IRC ................................................................ 29
3.3 Comunicación con servicios .................................................................... 29
4. Diseño e implementación ............................................................................. 30
4.1 Base de datos ......................................................................................... 31
4.2 Modelo de clases .................................................................................... 36
5. Desarrollo ..................................................................................................... 46
5.1 Croquis temporal ..................................................................................... 46
5.2 Servicios de ejemplo ............................................................................... 47
6. Herramientas ................................................................................................ 48
7. Software Libre .............................................................................................. 55
7.1 Introducción al software libre .................................................................. 55
7.2 Importancia del software libre en este proyecto ...................................... 56
8. Conclusiones ................................................................................................ 57
9. Bibliografía ................................................................................................... 58
3
Proyecto fin de carrera
Rubén Lozano Díaz
1. Introducción
1.1 Internet Relay Chat
1.1.1 Definición
IRC (Internet Relay Chat) es un protocolo de comunicación, bajo TCP/IP, en
tiempo real basado en texto, que permite debates en grupo o entre dos
personas y que está clasificado dentro de los servicios de comunicación en
tiempo real. Se diferencia de la mensajería instantánea en que los usuarios no
deben acceder a establecer la comunicación de antemano, de tal forma que
todos los usuarios que se encuentran en un canal pueden comunicarse entre
sí, aunque no hayan tenido ningún contacto anterior. Las conversaciones se
desarrollan en los llamados canales de IRC, grupos de usuarios que hablan
sobre un tema en común, designados por nombres que habitualmente
comienzan con el carácter # o & (este último sólo es utilizado en canales
locales del servidor). Es un sistema de charlas ampliamente utilizado por
personas de todo el mundo.
Los usuarios del IRC utilizan una aplicación cliente para conectarse con un
servidor, en el que funciona una aplicación IRCd (IRC Daemon o servidor de
IRC) que gestiona los canales y las conversaciones.
Desde el punto de vista de un cliente, se pueden observar, en gran mayoría
tres cosas: los usuarios1, los canales2 y los servidores3. Los usuarios, bajo un
nick u apodo, se conectarán a un servidor concreto y una vez autenticados en
el sistema tendrán acceso a salas de charla (canales) donde, junto con otros
1 Personas que podrán interactuar con otros usuarios en una red IRC.
2 Espacio virtual donde cierto numero de usuarios podrán recibir los mensajes que los demás usuarios
del canal envíen a éste.
3 También llamado HUB, los servidores son las unidades indivisibles de las que están formadas las
redes IRC enviando, procesando y recibiendo información tanto de usuarios como de otros servidores
para formar una red IRC.
4
Proyecto fin de carrera
Rubén Lozano Díaz
usuarios, podrán charlar de temas en común, usarlo de sitio de reunión,
organización de eventos, ciberjuegos y todo lo que pueda dar de sí la
comunicación textual. Si se desea, se puede mantener conversaciones
privadas con ciertos usuarios de tal manera que nadie más puede intervenir de
ninguna manera en esa conversación.
Figura 1 Estructura Clientes – Red IRC
Dentro de cada canal se juegan varios tipos de roles, usualmente:
•
El Operador: Denotado con una “@” delante del nick, es el usuario o
grupo de usuarios que tiene administración total sobre ese canal en
concreto, pudiendo nombrar operadores, “ayudantes”, echar a cualquier
usuario, banear (impedir durante cierto tiempo la entrada al canal) a
5
Proyecto fin de carrera
Rubén Lozano Díaz
usuarios, y editar las características del canal (contraseña, limite de
usuarios, edición del Topic o tema de conversación… etc).
•
El “Ayudante”: Denotado con un “+” delante del nick, suele ser el
encargado de recordar las normas del canal y encauzar los temas de
conversación por el camino correcto. No tiene más poder que ser en
cierta manera el “ojito derecho” de los operadores. Hay una
característica de los canales que un Operador puede modificar para que
en un canal únicamente puedan escribir Operadores y Ayudantes,
prohibiendo así el derecho de escritura al siguiente grupo, los Usuarios.
•
El Usuario: No tienen símbolos especiales, solo les acompaña su nick,
aportan ideas, temas y conversaciones a los canales y son el grueso de
los canales, esto no quiere decir que los operadores y los ayudantes
tengan cosas que decir en las conversaciones al mismo nivel que
cualquier usuario.
6
Proyecto fin de carrera
Rubén Lozano Díaz
1.1.2 Servidores
En informática, un servidor es un tipo de software que realiza ciertas tareas en
nombre de los usuarios. El término servidor ahora también se utiliza para
referirse al ordenador físico en el cual funciona ese software, una máquina
cuyo propósito es proveer datos de modo que otras máquinas puedan utilizar
esos datos. En nuestro caso hablaremos de los servidores que provee datos de
conexiones de usuarios a otros usuarios, canales.. etc.
Los servidores están a la escucha de conexiones entrantes tanto de Clientes
como de otros Servidores. Usaremos servidores que entiendan el protocolo
P10 de comunicación de IRC. Las conexiones de otros servidores vendrán por
el puerto de comunicaciones 4400 produciéndose así un NetJoin4. En cambio,
las conexiones con clientes vendrán por el puerto 6667.
Las conexiones por servidor requieren de una contraseña, cosa que una
conexión con cliente no. Los servidores tienen administradores llamados IRC
Operator 5 . Un IRC Operator podrá realizar Kills 6 sobre los servidores en
referencia a nicks o a máscaras de red (X@Y donde X es el host/ip del cliente e
Y es el ISP). Un Kill en un servidor se denomina K-Line e impedirá la entrada
de ese nick o host durante un tiempo determinado o indefinido especificado en
el comando lanzado por el IRC Operator. Por otro lado, un kill en una red IRC
se denomina G-Line que es un K-Line en todos los servidores de una red IRC.
Algo importante y necesario que pueden hacer los servidores es la propagación
de comandos en una Red IRC para informar a los otros servidores de las
acciones de cliente que se producen en el servidor o para informar sobre
eventos y acciones de servidor. La gran mayoria de propagaciones solo se
producen entre servidores y solo una minoria localizada se producirá entre
servidor y usuario.
4 Proceso de intercambio de información entre dos redes IRC al conectar entre ellas dos servidores.
5 Administrador de una red IRC en la que tiene el control total y absoluto.
6 Proceso por el cual se restringe el acceso a un usuario sobre un servidor en concreto.
7
Proyecto fin de carrera
Rubén Lozano Díaz
Dentro de los tipos de servidores, y el protocolo IRC, la forma de enviarse
mensajes varía de unos servidores a otros apareciendo de por medio los
protocolos de servidor. Muchos servidores cuelgan del uso de un protocolo
común con implementaciones, características, y especificaciones diferentes así
como servidores con características similares pueden tener un protocolo de
comunicación diferente. Todos los servidores que comparten el mismo
protocolo de mensajes pueden estar conectados entre ellos aunque hayan
estado programados por diferentes personas, en entornos diferentes y bajo
lenguajes que no tengan nada que ver gracias a la simpleza de recibir y enviar
cadenas de texto.
8
Proyecto fin de carrera
Rubén Lozano Díaz
1.1.3 Redes
Una red IRC esta formada por como mínimo un servidor. Los servidores tienen
un máximo de clientes conectados y de canales, todo determinado por cada
servidor y configurado por cada IRC Operator para un funcionamiento óptimo.
El punto fuerte de IRC es la parte distribuida. Dos usuarios en dos servidores
diferentes pueden compartir tema de conversación en un canal determinado y
compartir todo lo que nos ofrece una red IRC. Los puntos delicados de los
servidores son los puntos críticos:
1. NetJoin: Cuando un servidor conecta con cualquier otro servidor ya
conectado a una red lo que está haciendo es una propagación del comando de
la conexión de tal manera que todos los servidores de la red, en ese instante, le
mandarán
un
flujo
de
datos
con
los
canales,
los
usuarios,
los
modos/configuración de cada canal, los bans producidos, nicks y demás
información de cada servidor de tal manera que cada servidor se cuida de las
transacciones de sus clientes y sus canales, teniendo en cuenta toda la
información recibida. De esta manera en base a dos redes IRC independientes
se produce una tercera, que está formada por las dos anteriores.
2. NetSplit: Literalmente “separación de la red” ocurre cuando un servidor se
cae o es desconectado de la red llevándose con él todos los usuarios que tenia
conectados. De hecho no es una carga transaccional tan grande como un
netJoin, solo que es inesperado y no suele pasar, únicamente por razones de
mantenimiento o de inestabilidad de la red a la que está conectado el servidor.
9
Proyecto fin de carrera
Rubén Lozano Díaz
Figura 2 NetSplit en una red IRC
3. Bottleneck: En un determinado momento muchísimos usuarios lanzaran
peticiones a un único servidor produciendo un relentizamiento notable de éste
siendo pura casualidad, o mal intencionado (Ataque Distributed Denial Of
Service), peticiones masivas a un servidor con el objetivo de producir
problemas en servir peticiones de usuarios no mal intencionados.
10
Proyecto fin de carrera
Rubén Lozano Díaz
1.1.4 Clientes
Un cliente, sin referirse al cliente como el usuario que está conectado en una
red, sino como el sistema que permite una conexión es de lo que hablaremos
en esta sección.
Un cliente se conecta a un servidor por el puerto de comunicaciones 6667 y el
servidor introducirá este usuario en la red de la que forme parte.
A un cliente solo le llegará información que pida, o la propagación de los
usuarios que se unen o salen de los canales de la red IRC y los cambios de
estado de estos usuarios en los canales. En ningún caso recibirán
propagaciones de comandos de servidor como NetJoins, autentificaciones de
usuario, de servidor, etc.
La figura del IRC Operator no es otra que un cliente identificado como tal con
una contraseña. En este caso sí que el IRC Operator puede recibir información
privilegiada por los servidores, pero no por recepción de comandos propagados
sino por el envío de la información de la red al IRC Operator a través de un
servidor. Se produce la misma situación cuando un IRC Operator quiere
propagar un comando a la red; debe enviarlo primero a un servidor y éste
propagará el comando por él.
Uno de los clientes más usados es mIRC para Windows, muchos de los
clientes de Windows son modificaciones de mIRC.
11
Proyecto fin de carrera
Rubén Lozano Díaz
1.1.5 Servicios
Desde el punto de vista de un servidor, un cliente recibe y envía comandos; si
este usuario es de carne y hueso o es un software le es totalmente indiferente.
Tendremos servicios del servidor y/o servicios de los usuarios conectados a la
red haciendo tareas diversas.
Un administrador de un servidor puede querer registrar canales para que la
existencia de estos sea indefinida y esté ligado a uno o varios usuarios que
serán los Operadores del canal. Esto no viene por defecto con la mayoria de
servidores de IRC por lo que un IRC Operator puede hacer un Bot para que
escriba en una base de datos los canales y autentifique la creación, y
validación de estos.
Esto es solo un ejemplo de Servicio enfocado al servidor, pero también
podemos tener servicios que monitorizan los usuarios de la red, o servicios que
hacen de administradores de la propia red. Tambien puedes tener servicios en
canales específicos que en base a lo que los usuarios hablan en un canal
registre un log de mensajes, o incluso gracias a inteligencia artificial, un
servicios que registren componentes semánticos y pueda darte respuestas
concretas a preguntas independientemente del lenguaje (Monty Bot).
12
Proyecto fin de carrera
Rubén Lozano Díaz
1.1.6 Origen e historia
En los años 80 Jaiko Oikarinen trabajaba en el Departamento de Ciencia del
Procesamiento de la Información de la Universidad de Oulu. Como no tenía
mucho trabajo, empezó a desarrollar un programa de comunicaciones que
haría que las populares BBS (Bulletin Board System) fueran más usables. Los
BBS eran sistemas a los que te conectabas mediante Terminal para leer
noticias, descargar software, datos, etc. que estaban bastante “de moda”.
El propósito era permitir que allí hubiera discusiones y grupos del estilo de
las News de USENET (Users Network, sistema global de discusión en Internet),
además de discusiones en tiempo real y otras cosas relacionadas con la BBS.
Un sencillo programa llamado MUT (Multiuser Talk) ya existía en las BBS, el
problema era que no funcionaba debidamente, y a raíz de que Jyrki Kuoppala
había implementado el programa rmsg para enviar mensajes a gente en otras
máquinas pese a que no tenia implementado el concepto de canal (aunque lo
soportaba), se acabó implementando IRC para las BBS.
IRC vió la luz en Agosto de 1988, y más tarde cuando IRC empezó a tener
ocasionalmente más de 10 usuarios, Jarkko pidió a unos amigos suyos al sur
de Finlandia que pusieran en funcionamiento algunos servidores en la
universidad de Helsinki y en la de Tampere. Markku Jarvinen mejoró el cliente
de IRC por lo que pronto, la idea de añadir funciones a la BBS se vio que no
era buena idea, por lo que ésta fue abandonada y solo permaneció IRC.
Como punto interesante, IRC se hizo popular cuando fue utilizado en el intento
de golpe de estado en la Unión Soviética de 1991 para informar a través de un
periodo de censura en los medios. Fue utilizado de similar manera por los
Kuwaitíes durante la Invasión a Irak.
13
Proyecto fin de carrera
Rubén Lozano Díaz
1.2 Persistencia
Se entiende por persistencia como la acción de preservar la información de un
objeto de forma permanente (guardar), pero a su vez también se refiere a
poder recuperar la información del mismo (leer) para que pueda ser
nuevamente utilizada.
En el caso de persistencia de objetos la información que persiste en la mayoría
de los casos son los valores que contienen los atributos en ese momento, no
necesariamente la funcionalidad que proveen sus métodos.
Nota: La persistencia no es ni una capacidad ni una propiedad de la POO, no
tiene nada que ver con el paradigma en sí, solo es el mecanismo que se usa
para persistir información de un determinado tipo (como puede ser serializar,
guardar los datos en una tabla, en un archivo plano, etc).
Desde la óptica de la persistencia, se podrían clasificar los objetos en:
•
Transitorios: Cuyo tiempo de vida depende directamente del ámbito del
proceso que los instanció.
•
Persistentes: Cuyo estado es almacenado en un medio secundario para
su posterior reconstrucción y utilización, por lo que su tiempo de vida es
independiente del proceso que los instanció.
La persistencia permite al programador almacenar, transferir y recuperar el
estado de los objetos. Para esto existen varias técnicas:
•
Serialización
•
Motores de persistencia
•
Bases de datos orientadas a objetos
En el caso que nos ocupa, usaremos una base de datos ORACLE y una
herramienta objeto-relacional llamada Hibernate.
14
Proyecto fin de carrera
Rubén Lozano Díaz
1.2.1 ORACLE
Oracle es un sistema de gestión de base de datos relacional (o RDBMS por el
acrónimo en inglés de Relational Data Base Management System),
desarrollado por Oracle Corporation.
Se considera a Oracle como uno de los sistemas de bases de datos más
completos, destacando su:
Soporte de transacciones .
Estabilidad.
Escalabilidad.
Soporte multiplataforma.
Oracle surge a finales de los 70 bajo el nombre de Relational Software a partir
de un estudio sobre SGBD (Sistemas Gestores de Base de Datos) de George
Koch. Computer World definió este estudio como uno de los más completos
jamás escritos sobre bases de datos. Este artículo incluía una comparativa de
productos que erigía a Relational Software como el más completo desde el
punto de vista técnico. Esto se debía a que usaba la filosofía de las bases de
datos relacionales, algo que por aquella época era todavía desconocido.
En la actualidad, Oracle todavía encabeza la lista. La tecnología Oracle se
encuentra prácticamente en todas las industrias alrededor del mundo y en las
oficinas de 98 de las 100 empresas Fortune 100. Oracle es la primera
compañía de software que desarrolla e implementa software para empresas
100 por ciento activado por Internet a través de toda su línea de productos:
base de datos, aplicaciones comerciales y herramientas de desarrollo de
aplicaciones y soporte de decisiones. Oracle es el proveedor mundial líder de
software para administración de información, y la segunda empresa de
software.
15
Proyecto fin de carrera
Rubén Lozano Díaz
Oracle a partir de la versión 10g Release 2, cuenta con 5 ediciones:
Oracle Database Enterprise Edition(EE).
Oracle Database Standard Edition (SE).
Oracle Database Standard Edition One (SE1).
Oracle Database Express Edition (XE).
Oracle Database Personal Edition (PE).
La única edición gratuita es la Express Edition, que es compatible con las
demás ediciones de Oracle Database 10gR2 y Oracle Database 11g.
La que usaremos en este proyecto será Oracle Database Express Edition (XE).
Figura 3 Estructura Oracle DB
16
Proyecto fin de carrera
Rubén Lozano Díaz
1.2.2 Hibernate
Hibernate es una herramienta de Mapeo objeto-relacional para la plataforma
Java (y disponible también para .Net con el nombre de NHibernate) que facilita
el mapeo de atributos entre una base de datos relacional tradicional y el
modelo de objetos de una aplicación, mediante archivos declarativos (XML)
que permiten establecer relaciones a nivel de objetos.
Hibernate es software libre, distribuido bajo los términos de la licencia GNU
LGPL.
La característica primaria de Hibernate es mapear clases de Java sobre tablas
de bases de datos (y de tipos de datos de Java a tipos de datos de SQL).
También proporciona ayuda para consulta y obtención de datos. Hibernate
genera las llamadas de SQL y le quita al desarrollador la tarea de tratar la
llamada y la conversión a los objetos a los que desea convertir, dejando la
aplicación portable a todas las bases de datos SQL, a cambio de solo un
pequeño pico en rendimiento.
Figura 4 Esquema arquitectura de hibernate
17
Proyecto fin de carrera
Rubén Lozano Díaz
Como todas las herramientas de su tipo, Hibernate busca solucionar el
problema de la diferencia entre los dos modelos de datos coexistentes en una
aplicación: el usado en la memoria de la computadora (orientación a objetos) y
el usado en las bases de datos (modelo relacional). Para lograr esto permite al
desarrollador detallar cómo es su modelo de datos, qué relaciones existen y
qué forma tienen. Con esta información Hibernate le permite a la aplicación
manipular los datos de la base operando sobre objetos, con todas las
características de la POO. Hibernate convertirá los datos entre los tipos
utilizados por Java y los definidos por SQL. Hibernate genera las sentencias
SQL y libera al desarrollador del manejo manual de los datos que resultan de la
ejecución de dichas sentencias, manteniendo la portabilidad entre todos los
motores de bases de datos con un ligero incremento en el tiempo de ejecución.
Hibernate está diseñado para ser flexible en cuanto al esquema de tablas
utilizado, para poder adaptarse a su uso sobre una base de datos ya existente.
También tiene la funcionalidad de crear la base de datos a partir de la
información disponible.
Hibernate ofrece también un lenguaje de consulta de datos llamado HQL
(Hibernate Query Language), al mismo tiempo que una API para construir las
consultas programáticamente (conocida como "criteria").
Hibernate para Java puede ser utilizado en aplicaciones Java independientes o en
aplicaciones Java EE, mediante el componente Hibernate Annotations que implementa
el estándar JPA, que es parte de esta plataforma.
18
Proyecto fin de carrera
Rubén Lozano Díaz
1.3 Protocolos de comunicación
Los protocolos son reglas de comunicación que permiten el flujo de información
entre computadoras distintas que manejan lenguajes distintos, por ejemplo, dos
computadores conectados en la misma red pero con protocolos diferentes no
podrían comunicarse jamás, para ello, es necesario que ambas "hablen" el
mismo idioma, por tal sentido, el protocolo TCP/IP fue creado para las
comunicaciones en Internet, para que cualquier computador se conecte a
Internet, es necesario que tenga instalado este protocolo de comunicación.
Los protocolos implantados en sistemas de comunicación con un amplio
impacto, suelen convertirse en estándares, debido a que la comunicación e
intercambio de información (datos) es un factor fundamental en numerosos
sistemas, y para asegurar tal comunicación se vuelve necesario copiar el
diseño y funcionamiento a partir del ejemplo pre-existente. Esto ocurre tanto de
manera informal como deliberada.
Existen consorcios empresariales, que tienen como propósito precisamente el
de proponer recomendaciones de estándares que se deben respetar para
asegurar la interoperabilidad de los productos (p.e. W3C).
19
Proyecto fin de carrera
Rubén Lozano Díaz
1.3.1 HTTP
El protocolo de transferencia de hipertexto (HTTP, HyperText Transfer
Protocol) es el protocolo usado en cada transacción de la Web (WWW). HTTP
fue desarrollado por el consorcio W3C y la IETF, colaboración que culminó en
1999 con la publicación de una serie de RFC, siendo el más importante de ellos
el RFC 2616, que especifica la versión 1.1.
HTTP define la sintaxis y la semántica que utilizan los elementos software de la
arquitectura web (clientes, servidores, proxies) para comunicarse. Es un
protocolo orientado a transacciones y sigue el esquema petición-respuesta
entre un cliente y un servidor. Al cliente que efectúa la petición (un navegador o
un spider) se lo conoce como "user agent" (agente del usuario). A la
información transmitida se la llama recurso y se la identifica mediante un URL.
Los recursos pueden ser archivos, el resultado de la ejecución de un programa,
una consulta a una base de datos, la traducción automática de un documento,
etc.
HTTP es un protocolo sin estado, es decir, que no guarda ninguna información
sobre conexiones anteriores. El desarrollo de aplicaciones web necesita
frecuentemente mantener estado. Para esto se usan las cookies, que es
información que un servidor puede almacenar en el sistema cliente. Esto le
permite a las aplicaciones web instituir la noción de "sesión", y también permite
rastrear usuarios ya que las cookies pueden guardarse en el cliente por tiempo
indeterminado.
20
Proyecto fin de carrera
Rubén Lozano Díaz
1.3.2 XML-RPC
XML-RPC es
un protocolo
de
llamada
usa XML(Extensible Markup Language) para
a
procedimiento
codificar
los
remoto que
datos
y HTTP(HyperText Transfer Protocol) como protocolo de transmisión de
mensajes.
Es un protocolo muy simple ya que sólo define unos cuantos tipos de datos y
comandos útiles, además de una descripción completa de corta extensión. La
simplicidad del XML-RPC está en contraste con la mayoría de protocolos RPC
que tiene una documentación extensa y requiere considerable soporte de
software para su uso.
Fue creado por Dave Winer de la empresa UserLand Software en asociación
con Microsoft en el año 1998. Al considerar Microsoft que era muy simple
decidió añadirle funcionalidades, tras las cuales, después de varias etapas de
desarrollo, el estándar dejó de ser sencillo y se convirtió en lo que es
actualmente conocido como SOAP. Una diferencia fundamental es que en los
procedimientos en SOAP los parámetros tienen nombre y no interesan su
orden, no siendo así en XML-RPC.
Figura 5 Modelo XML-RPC
21
Proyecto fin de carrera
Rubén Lozano Díaz
Según la especificación de XML-RPC, los principales tipos de datos son:
•
Array: Arreglo de valores, sin almacenar llaves.
•
Base64: Datos binarios codificados en base 64.
•
Boolean: Valor lógico (0 o 1).
•
Date/Time: Día y hora.
•
Double: Número de coma flotante de doble precisión
•
Integer: Número entero.
•
String: String (cadena) de caracteres.
•
Struct: Arreglo de valores, almacenando llaves.
•
Nil: Valor nulo.
El echo de escoger este sistema es por la gran variedad de implementaciones
que existen, y en el caso de que no existiera para un lenguaje/plataforma
determinados, al haber un número pequeño de tipos de datos se podría
implementar con un coste temporal relativamente bajo.
22
Proyecto fin de carrera
Rubén Lozano Díaz
2. Motivación y objetivos del proyecto
2.1 Objetivos
Se pretende implementar un servidor que sirva para procesar cualquier tipo de servicio
asociado a una red de servidores de IRC mediante un protocolo que abstraiga la
comunicación cliente-servidor a un punto donde de igual el lenguaje en el que estés
programando. La modificación, agregación o supresión de servicios deberá ser de una
manera fácil y rápida.
Esta implementación deberá poder almacenar datos referentes a la red IRC a la que el
servidor esté conectado. También deberá dar una arquitectura de soporte para
implementaciones de protocolos de red IRC.
Se tendrá en cuenta la seguridad de las conexiones de servicios asignando privilegios a
ciertos usuarios. Estos privilegios pasan por la ejecución de rutinas concretas en el
servicio y de llamadas concretas a la base de datos, de tal manera que un servicio que no
tenga el privilegio de hacer inserciones no podrá insertar datos en las tablas concretas
donde no tenga privilegios.
23
Proyecto fin de carrera
Rubén Lozano Díaz
2.2 Motivación
Al escoger XML-RPC hemos optado por sencillez y por resultados. Está más
que probado como un estándar fiable, estructurado y estable que proporciona
resultados. Al proporcionar servicios a través de XML-RPC podemos asegurar
una comunicación multiplataforma y multilenguaje. En este caso el servidor
está hecho bajo tecnología Java pero al usar XML-RPC como protocolo de
intercambio de información nos da igual qué haya al otro lado porque lo que
nos envían es información que podemos entender en cualquier lenguaje y
plataforma. Esto surge del hecho de que se necesitan lenguajes concretos para
conseguir información de redes IRC y de sus servicios asociados como el
lenguaje C, y en el caso de que no quisieras usar este lenguaje, te tienes que
hacer tú mismo las rutinas de parseo de datos y de comunicación llegando
incluso a crearte tu propio servidor.
Por otro lado tenemos la facilidad de programación, con el Framework
enviamos ordenes sencillas y esperamos identificadores sencillos con los que
poder trabajar de inmediato, en cambio, de otra manera se debería
implementar un protocolo de información dependiendo de cada servidor al que
quieres conectar.
24
Proyecto fin de carrera
Rubén Lozano Díaz
El hecho de proporcionar una herramienta flexible, fácil de usar y versátil
supone una mejora muy grande para el mundo en los servicios a IRC:
-Flexible: El Framework está totalmente modularizado por lo que soporta
no solo nuevos protocolos de IRC modificando muy poco código sino que
también soporta nuevos módulos de servicios.
-Fácil de usar: Únicamente debemos lanzar funciones de código a través
de XML-RPC con los parámetros indicados en las especificaciones para poder
obtener resultados.
-Versátil: XML-RPC es un estándar en el que esta basadas muchas
otras herramientas. A un nivel básico también podríamos usar estas
herramientas complejas para lanzar acciones sobre el Framework. Enfocándolo
por otro sitio, al ser un estándar es un protocolo muy enseñado y en cuanto a
llamadas a procedimientos remotos, esto es la base.
25
Proyecto fin de carrera
Rubén Lozano Díaz
3. Especificaciones
A grosso modo se pueden diferenciar tres grandes módulos en la Estructura:
Servicios: Se encargará de recibir conexiones externas. Proporcionará
datos o ejecutará las acciones que los servicios externos hayan pedido
tanto sobre el modulo IRC como la persistencia. También podrá enviar
información que reciba del bloque IRC sin necesidad de que le sea
pedida cada vez.
Persistencia: Se encargará de almacenar los datos que han de
mantenerse persistentes del modulo de servicios y del de IRC.
IRC: Se encargará de llevar las conexiones a redes IRC y de informar a
los servicios que le pidan información.
Figura 6 Mapa módulos
26
Proyecto fin de carrera
Rubén Lozano Díaz
3.1 Persistencia
Es el modulo que se encargará de guardar indefinidamente la información que
le sea transferida, y será el que ha de devolver los datos que le sean
requeridos.
Diferenciaremos dos tipos de grandes bloques que deben ser persistentes:
Datos IRC: Cuando le sea requerido, se deben poder guardar los
siguientes datos:
Usuarios: Será la cuenta de uso sobre la red IRC. Tendrá
asociado una contraseña, los nicks que tenga registrados, e-mail,
estado de cuenta, y roles asociados.
Nicks: Varios nicks estarán asociados a un Usuario registrado.
Guardará la fecha de último uso, la fecha de creación y el estado.
Roles: Un rol determinado que pueda tener cierto Usuario en la
red IRC asociada.
Privilegios: Estarán asociados a Roles de tal manera que un
Usuario tendrá ciertos privilegios indirectamente definidos por los
Roles que tiene definidos, o podremos relacionar ciertos
privilegios directamente a un Usuario.
Canales: Cierto usuario podría registrar un canal en la red IRC en
el que constará como fundador y para el que será Operador en el
momento que se valide, además de guardar toda la información
relacionada con el canal en el instante de ser guardada.
Mensajes:
Se
guardarán
mensajes
entre
usuarios
como
correspondencia entre ellos.
Bans: Se podrán guardar los bans que tenga un canal.
G-lines: Se podrán guardar los G-lines que tenga una red.
27
Proyecto fin de carrera
Rubén Lozano Díaz
Datos Servicios: Servicios querrán conectarse al framework, pero no
todos los servicios tendrán el nivel de acceso máximo para ejecutar
cualquier petición sobre los módulos. Por este motivo se mantendrá
persistente un registro de servicios identificados por usuario y
contraseña que tendrán asociados unos privilegios. Estos privilegios
serán los que les permitan hacer ciertas acciones.
Este módulo tendrá dos capas:
Base de datos: La capa de la persistencia en sí con una base de datos
que no tiene por qué estar en la misma máquina del Framework. A la
que solo será accesible la capa de los Data Access Object.
Data Access Object: No accederemos a la base de datos directamente,
sino que usaremos Hibernate. Nos proporcionará la información de la
base de datos sin tener que abandonar el paradigma orientado a
objetos.
28
Proyecto fin de carrera
Rubén Lozano Díaz
3.2 Comunicación con Redes IRC
Es el módulo que conectará a redes IRC gracias a una interfaz que permitirá
conexiones con redes que usen cualquier tipo de protocolo de transferencia de
datos entre servidores.
Deberá guardar los objetos de la red en memoria para poder responder a las
peticiones de los servicios con la mayor brevedad posible, ya sean operaciones
de persistencia, como de petición de datos de la red.
Las operaciones de persistencia que impliquen objetos en memoria del módulo
de IRC, deberán hacerse a través de este. También deberá soportar un
sistema de registro a ciertos comandos para poder informar a los servicios que
lo requieran sobre cambios en la red en el subconjunto especificado.
3.3 Comunicación con servicios
Es el modulo que permitirá ejecutar lo que les servicios le pidan y devolverá los
datos que le sean requeridos siempre y cuando cumplan con los privilegios
suficientes como para poder ejecutar/solicitar lo que el servicio necesite. El
administrador del framework será la única interfaz que podrá añadir o quitar
cuentas de servicio y de asignarles los respectivos privilegios.
Será el módulo principal porque a partir de las conexiones con los servicios se
llamarán a funcionalidades de los otros módulos. Existe cierta independencia
entre el modulo de persistencia y el modulo de IRC pero estos dos tienen
dependencia total sobre el modulo de Servicios.
29
Proyecto fin de carrera
Rubén Lozano Díaz
4. Diseño e implementación
Después de una fase de análisis y recogida de requerimientos
se decidió
separar el diseño en tres fases:
Base de datos: Se necesitaba la creación y conectividad con una base de datos
para poder guardar cualquier tipo de dato relacionado con una red IRC además
de proporcionar una capa de abstracción entre la base de datos y el código. Se
procedió con un diseño Entidad-Relación que posteriormente fue implementado
mediante SQL sobre una Oracle Database Express Edition. La siguiente capa
por debajo de la orientación a objetos se implementó con Hibernate, que
gracias a sus herramientas de ingeniería inversa solo hacía falta tener creada
la base de datos para la autogeneración de todo lo necesario.
Paquete IRC: Se necesitaba una estructura con la que solo hiciera falta la
programación del código concreto a ejecutar para eventos de servidor, y el
código del protocolo de IRC concreto para llamar a estos eventos. Gracias la
arquitectura del Jibble PircBot solo se tuvo que tener en cuenta los eventos de
servidor, ya que la estructura de PircBot está orientada al cliente y no al
servidor. A partir de aquí, se necesitaba una implementación concreta con la
que poder hacer pruebas. IRC Hispano es un protocolo de IRC muy fiable y
cada vez más usado, se decidió usar éste para las pruebas por lo que la
siguiente fase era la implementación de este protocolo usando la estructura.
Paquete XML-RPC: En principio este módulo debía ser fácil y rápido de
programar, solo queríamos estar a la escucha de conexiones entrantes
validarlas, y devolver un resultado, además también estaba la utilidad de estar
a la escucha de comandos concretos. No fue tan fácil y rápido porque la
implementación de xml-rpc para Java no ofrecía la posibilidad de validar
usuario, contraseña y obtener al mismo tiempo los datos de la conexión y el
nombre del método que se quería ejecutar. Se tuvo que modificar el núcleo de
este módulo que al ser código abierto no hubo problema alguno en leer,
estudiar y modificar.
30
Proyecto fin de carrera
Rubén Lozano Díaz
4.1 Base de datos
Estas tres tablas son muy importantes y sirven para almacenar los datos de
validación de cada servicio y poder relacionarlos con los privilegios que tienen.
Podemos observar que los privilegios sobre los servicios son acumulativos y
podremos tener tantos privilegios asignados a un servicio como queramos, no
obstante con guardar estos datos no basta. Es posible que algún servicio
quiera tener persistencia de algún objeto de la red IRC en nuestra estructura y
por lo tanto se lo debemos dar de una manera controlada y accesible para los
otros servicios que quieran verlo. Esta sería la parte “publica” de los datos, no
obstante, los servicios que tengan los suficientes privilegios podrían crearse
sus propias tablas privadas en la base de datos a través de SQL.
De esta manera, para obtener el modelo Entidad-Relación de las tablas,
debemos mirar al apartado de persistencia de las especificaciones. IRC está
orientado a usuarios, y todo
31
Proyecto fin de carrera
Rubén Lozano Díaz
Figura 7 Diagrama de las tablas de la base de datos
32
Proyecto fin de carrera
Rubén Lozano Díaz
Para que la estructura pueda trabajar sin perder la orientación a objetos con las
tablas públicas, se ha usado Hibernate y sus herramientas de ingeniería
inversa para dar transparencia a las operaciones con la base de datos.
Figura 8 Fichero de configuración
Configurando un fichero de configuración, añadiendo el driver para JDBC al
directorio del proyecto solo queda añadir cómo relacionaremos las tablas con
objetos.
Figura 9 Parte de la configuración de las herramientas de ingeniería inversa
33
Proyecto fin de carrera
Rubén Lozano Díaz
Una vez configurado el entorno hibernate ejecutaremos la herramienta de
ingeniería inversa y nos generará los beans y los ficheros de mapeo.
Figura 10 Ficheros generados por hibernate
Excepto algunas clases que ya teníamos en el paquete
beans
podemos
observar que hibernate nos ha creado todos los objetos de la base de datos, y
sus correspondientes mappings.
34
Proyecto fin de carrera
Rubén Lozano Díaz
El siguiente paso para tener la parte de la base de datos terminada es la
creación de los DAO (Data Access Object) para cada tipo de objeto que
permitirá la escrituras, lecturas, borrados y consultas sobre nuestros datos. El
framework trabaja sobre un DAO Base que implementa escritura, borrado,
modificado y consulta por id básico.
Figura 11 Estructura del DAO Base
35
Proyecto fin de carrera
Rubén Lozano Díaz
4.2 Modelo de clases
El proyecto no es excesivamente complejo, pero por su extensión, por la
cantidad de clases y métodos, un diagrama de clases convencional no es una
opción posible para mostrar el trabajo por lo que debemos recurrir a este
diagrama de paquetes donde mostramos la información y clases clave.
Figura 12 Diagrama de paquetes
36
Proyecto fin de carrera
Rubén Lozano Díaz
Paquete beans
Observamos lo que hemos visto con anterioridad; tenemos las clases
autogeneradas que se utilizarán como datos a guardar o recuperar de la base
de datos. En estas implementaciones hemos ubicado otras clases en beans
“especiales” que nos sirven para tener un estado actualizado en tiempo real en
memoria. Como tener un control exhaustivo de toda la información de cada
Nick es un coste de memoria que no es necesario, se ha definido otra clase
vean para representar un Nick con información obligatoria. Además, a la hora
de programar la prueba se ha tenido que diseñar una estructura que resida en
memoria que lleve actualizado en tiempo real la relación entre usuarios –
canales de tal manera que las consultas del estado de la red nos devuelvan
resultados con coste constante, como por ejemplo en qué canales está ubicado
un nick concreto.
Figura 13 Diseño datos en memoria
Cabe decir que este diseño puede ser diferente para cada implementación
pero se presenta como base para poder ser utilizado.
37
Proyecto fin de carrera
Rubén Lozano Díaz
Paquete DAO
En este paquete se llevaran a cabo todas las transacciones con la base de
datos. El proyecto cuando necesita acceder a la base de datos para cualquier
cosa, tiene que pasar por los DAO, de otra manera no podrá conectarse a la
base de datos.
En la clase BaseDAO tenemos los métodos básicos que todos los demás DAO
también tienen por herencia, no obstante es posible crear métodos específicos
a los DAO dependiendo de necesidades especiales como consultas especiales,
o procesos batch necesarios.
Figura 14 Codigo del metodo "isAutorized"
38
Proyecto fin de carrera
Rubén Lozano Díaz
Como método especial tenemos “isAutorized” en BotDAO. A este método se le
llama desde el núcleo del package xmlrpc como veremos más adelante y
devuelve un valor booleano que indica si el servicio está autorizado o no. Este
método primero se encarga de comprobar que el usuario y contraseña coincide
con la almacenada en la base de datos que gracias a hibernate se nos
presenta como un conjunto de métodos encadenados que nos devuelven un
resultado. Inmediatamente después comprobará que este servicio que se ha
conectado, tiene permisos para hacer lo que quiere hacer. En caso de que el
servicio no pueda ejecutarlo, devolverá un mensaje de error, por el contrario
devolverá lo que la rutina deba devolver. Podemos observar en la segunda
mitad del código de este método la forma de registrar observers, se hace así
porque se necesita la información de conexión para devolver los datos a los
que se han registrado.
39
Proyecto fin de carrera
Rubén Lozano Díaz
Paquete Net
En este paquete tenemos todo lo relacionado con las redes IRC. Tenemos
como pilar fundamental la clase abstracta VirtualNode. Ésta clase nos
proporciona una arquitectura para el intercambio de mensajes entre
servidores/clientes o servidores/servidores en redes IRC siendo esta parte, y la
parte de los objetos en memoria en tiempo real las partes más importantes en
el tratamiento de información.
Figura 15 Declaración métodos abstractos de la arquitectura que presenta VirtualNode
40
Proyecto fin de carrera
Rubén Lozano Díaz
Para poder implementar un protocolo de red IRC solo tendremos que hacer que
nuestra clase herede de VirtualNode. Nuestra clase solo tendrá que conectar al
dominio/ip deseado mediante el método “connect” y a partir de aquí en el
método “handleLine” recibiremos las líneas de texto que va recibiendo nuestro
servidor por parte de clientes/servidores de IRC, así que tendremos que
parsear el texto para convertirlo en los comandos que queramos y usemos los
tokens disponibles notificando a los observers que estén registrados. Toda la
capa baja de envío/recepción de datos ya está cubierta por la arquitectura de
VirtualNode y nosotros solo tenemos que ocuparnos de la capa alta del
parseado de texto.
Estos notify se verán sujetos al método “sendStrings” de la interfície
NetListener que se verá implementada dentro del paquete xmlrpc por la clase
BotClient.
41
Proyecto fin de carrera
Rubén Lozano Díaz
Paquete XMLRPC
Este paquete es el que proporcionará el nombre de “servidor” a nuestra
estructura
ya que la clase principal FwkServerServices será la que se
encargue de lanzar el servidor que escuchará las peticiones que le sean
enviadas a través de un puerto dado. Esta clase también se encarga de
mapear los métodos que pueden ser ejecutados (previa validación) por los
servicios. Según se vayan ampliando los servicios se añadirán en
“getMappings” las rutinas nuevas que se quieran añadir.
Figura 16 Método que inserta mapeos de rutinas
Si nos fijamos podemos observar que realmente la conexión con un servidor
IRC no es más que un modulo añadido en “getMappings” en la primera línea.
Un servicio debe ser el que le diga al servidor a qué red de IRC conectarse a
través de un HUB. Además la base de datos es otro modulo más y de la misma
42
Proyecto fin de carrera
Rubén Lozano Díaz
manera que hemos añadido estos módulos se podrían añadir infinidad de
módulos que completaran los servicios que pueda ofrecer esta estructura.
La parte que se ha tenido que cambiar, no ha sido un cambio muy grande, ni
han sido muchas líneas de código, lo complejo de este cambio ha sido buscar
qué modificar para no comprometer la funcionalidad del modulo, sin excesivas
líneas de código.
Figura 17 Modificaciones en modulo xmlrpc
Solo se ha cambiado la cabecera del método mostrado en la figura anterior y la
condición donde se evalúa si el servicio está autorizado. Se ha escogido este
punto porque la clase que llama al método “execute” reúne las condiciones y
los datos necesarios para la finalidad y funcionalidad de esta estructura, poder
reunir en un mismo sitio usuario, contraseña, nombre de rutina, parámetros de
llamada a la rutina, dirección de red y puerto. El usuario y la contraseña son
vitales para una validación así como la dirección de red por tal de diferenciar
43
Proyecto fin de carrera
Rubén Lozano Díaz
entre servicios que están a la escucha de comandos para poder lanzar la
conexión en sentido contrario usando el puerto que también se pasa en la
cabecera y el nombre y los parámetros. El registro de escucha de parámetros
se hace así porque por las vías normales no se puede obtener la dirección de
red del cliente, por lo que no podríamos lanzar la conexión saliente.
La parte del registro de eventos por parte de servicios se realiza en este
paquete. Parece raro porque el objeto observers figura en el paquete “Net” no
obstante quien puede obtener las direcciones de red es el paquete “xmlrpc” y
siendo éste el módulo principal y los módulos de IRC y base de datos módulos
secundarios, no es extraño ver que se procede de esta manera.
44
Proyecto fin de carrera
Rubén Lozano Díaz
Figura 18 Lanzamiento de eventos a servicios
Especial mención al método de la figura superior, “client” es un objeto del
mismo tipo que crean los servicios para conectarse con nuestro servidor.
Ejecutamos una llamada asíncrona para no bloquear el modulo servidor de
llamadas de la red IRC. Llamaremos al servicio que nos pidió el registro al
evento que estamos lanzando a la dirección que obtuvimos en la conexión, a
través del puerto especificado
45
Proyecto fin de carrera
Rubén Lozano Díaz
5. Desarrollo
5.1 Croquis temporal
Éste es el croquis temporal programado inicialmente para el proyecto. Cabe
decir que se ha cumplido bastante bien, quitando un poco de tiempo a la
implementación de las operaciones de IRC y añadiéndole tiempo
a las
operaciones de XML-RPC por la dificultad añadida de haber tenido que
modificar el núcleo del paquete que estábamos utilizando para la capa de red
de XML-RPC.
Semanas
Diseño BD
Creacion BD
Modelo de datos Hibernate
Diseño operaciones server IRC
Diseño estructura datos IRC
Implementación operaciones IRC
Diseño operaciones XML-RPC
Implementación metodos XML-RPC
Diseño Bots ejemplo
Implementacion Bots Ejemplo
TestCases y resolucion errores
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Figura 19 Croquis temporal
46
Proyecto fin de carrera
Rubén Lozano Díaz
5.2 Servicios de ejemplo
Se han programado 3 tipos de servicios para los ejemplos:
•
Servicio de monitorización visual:
Este es un servicio que está a la escucha de todos los usuarios de la red
IRC y de los canales donde están ubicados. La gracia está en que un
servicio conectado directamente a la red no puede ver la actividad de
cada usuario en cada canal, pero a través de nuestro servicio sí.
•
Servicio de administración de Nicks:
Servicio que estará conectado al servidor de IRC y al servidor de
servicios simultáneamente de tal manera que los usuarios de IRC
podrán pedirle acciones concretas que el servicio solo podrá ejecutar a
partir del servidor de servicios.
•
Servicio de monitorización en lenguaje C:
Servicio programado en C para demostrar la compatibilidad con otros
lenguajes a parte de Java que irá mostrando por pantalla todas las
acciones que el servidor realiza.
47
Proyecto fin de carrera
Rubén Lozano Díaz
6. Herramientas
•
Hibernate Reverse Engineering Tools
Herramienta integrada dentro del paquete Hibernate Tools, que permite la
generación de archivos de configuración, Beans, Mappings y todos los
archivos necesarios para poder centrarse en el uso de Hibernate en vez de
centrarse en la configuración a partir de una base de datos. Esto nos ahorra
el trabajo de varios días, incluso semanas, y nos proporciona unas clases y
unos archivos de mapeo y configuración estables, compactos y consolidados
con el entorno que estamos trabajando.
Más información: https://www.hibernate.org/255.html
•
Log 4 Java
Log4j es una biblioteca open source
desarrollada en Java por la Apache
Software Foundation que permite a los
desarrolladores de software elegir la
salida y el nivel de granularidad de los
mensajes o “logs” a tiempo de ejecución
y no a tiempo de compilación como es comúnmente realizado. La
configuración de salida y granularidad de los mensajes es realizada a tiempo
de ejecución mediante el uso de archivos de configuración externos. Log4J
ha sido implementado en otros lenguajes como: C, C++, C#, Perl, Python,
Ruby y Eiffel.
Más información: http://logging.apache.org/log4j/1.2/index.html
48
Proyecto fin de carrera
•
Rubén Lozano Díaz
JUnit
JUnit es un conjunto de bibliotecas creadas por Erich Gamma y Kent Beck que
son utilizadas en programación para hacer pruebas unitarias de aplicaciones
Java.
JUnit es un conjunto de clases (framework) que permite realizar la ejecución de
clases Java de manera controlada, para poder evaluar si el funcionamiento de
cada uno de los métodos de la clase se comporta como se espera. Es decir, en
función de algún valor de entrada se evalúa el valor de retorno esperado; si la
clase cumple con la especificación, entonces JUnit devolverá que el método de
la clase pasó exitosamente la prueba; en caso de que el valor esperado sea
diferente al que regresó el método durante la ejecución, JUnit devolverá un fallo
en el método correspondiente.
JUnit es también un medio de controlar las pruebas de regresión, necesarias
cuando una parte del código ha sido modificado y se desea ver que el nuevo
código cumple con los requerimientos anteriores y que no se ha alterado su
funcionalidad después de la nueva modificación.
El propio framework incluye formas de ver los resultados (runners) que pueden
ser en modo texto, gráfico (AWT o Swing) o como tarea en Ant.
En la actualidad las herramientas de desarrollo como NetBeans y Eclipse
cuentan con plug-ins que permiten que la generación de las plantillas
necesarias para la creación de las pruebas de una clase Java se realice de
manera automática, facilitando al programador enfocarse en la prueba y el
resultado esperado, y dejando a la herramienta la creación de las clases que
permiten coordinar las pruebas.
Más información: http://www.junit.org/
49
Proyecto fin de carrera
•
Rubén Lozano Díaz
WSXML-RPC implementación de Apache
XML-RPC es un protocolo de llamada a procedimiento remoto que usa XML
para codificar los datos y HTTP como protocolo de transmisión de mensajes.
Es un protocolo muy simple ya que sólo define unos cuantos tipos de datos y
comandos útiles, además de una descripción completa de corta extensión. La
simplicidad del XML-RPC está en contraste con la mayoría de protocolos RPC
que tiene una documentación extensa y requiere considerable soporte de
software para su uso.
Más información: http://ws.apache.org/xmlrpc/
•
Oracle DB Express edition 10g
Versión gratuita de la plataforma de base de datos que hemos visto en el
apartado 1.2.1 en base a OracleDB 10g release 2 compatible con 11g.
Más información:
http://www.oracle.com/technology/products/database/xe/index.html
•
SQL Developer
Oracle SQL Developer es una herramienta grafica para el desarrollo de bases
de datos gratuita y con soporte total por parte de Oracle. Con SQL Developer,
se puede navegar entre los objetos de la base de datos, ejecutar sentencias y
scripts de SQL y editar y debujar sentencias PL/SQL.
Más información:
http://www.oracle.com/technology/products/database/sql_developer/index.html
50
Proyecto fin de carrera
•
Rubén Lozano Díaz
Servidor IRC Hispano P10
Implementación del protocolo de IRC P10 de Undernet .
Más información: http://ircuhispano.wordpress.com/
•
Cliente IRC mIRC
mIRC el cliente IRC más extendido para plataformas Microsoft Windows.
Su autor es Khaled Mardam-Bey, es software con licencia shareware y su
periodo de evaluación es de 30 días (la última versión es de 45 días). Pasado
el periodo de evaluación para poder seguir utilizando el programa hay que
pagar una licencia de $20 USD válida para cualquier nueva versión de mIRC.
Si no se paga la licencia el programa en realidad no se inhabilita, simplemente
hay que esperar un corto tiempo cada vez que se ejecuta para poder utilizarlo.
Más información: http://www.mirces.com/
•
Jibble PircBot
PircBot es un framework de java para escribir bots de IRC de una forma rápida
y sencilla. Incluye una arquitectura dirigida a eventos para manejar los propios
eventos de IRC, protección de Flood, soporte para continuar DCC, soporte
ident y mucho más. El formato comprensible del archivo de logs es perfecto
para usarlo con PISG para generar estadísticas de canal. La documentación
entera está incluida y su página contiene una guía paso por paso para hacer tu
primero IRC bot.
Se conoce que el framework lo usan tanto la marina como la fuerza aerea de
Estados Unidos así como la CIA (sin confirmar) y varias agencias de seguridad
nacional. También se sabe que el cliente de bittorrent Azureus también lo usa.
Más información: http://www.jibble.org/pircbot.php
51
Proyecto fin de carrera
•
Rubén Lozano Díaz
Eclipse Ganymede
En su versión 3.4 Eclipse es
denominado
Eclipse
Ganymede. Es un entorno de
desarrollo integrado de código
abierto multiplataforma para desarrollar lo que el proyecto llama "Aplicaciones
de Cliente Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en
navegadores. Esta plataforma, típicamente ha sido usada para desarrollar
entornos de desarrollo integrados (del inglés IDE), como el IDE de Java
llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega
como parte de Eclipse (y que son usados también para desarrollar el mismo
Eclipse). Sin embargo, también se puede usar para otros tipos de aplicaciones
cliente, como BitTorrent Azureus.
Eclipse fue desarrollado originalmente por IBM como el sucesor de su familia
de herramientas para VisualAge. Eclipse es ahora desarrollado por la
Fundación Eclipse, una organización independiente sin ánimo de lucro que
fomenta una comunidad de código abierto y un conjunto de productos
complementarios, capacidades y servicios.
Más información: http://www.eclipse.org/
52
Proyecto fin de carrera
•
Rubén Lozano Díaz
Subversion
Subversion es un software de sistema de control de versiones diseñado
específicamente para reemplazar al popular CVS, el cual posee varias
deficiencias. Es software libre bajo una licencia de tipo Apache/BSD y se le
conoce también como svn por ser ese el nombre de la herramienta de línea de
comandos. Una característica importante de Subversion es que, a diferencia de
CVS, los archivos versionados no tienen cada uno un número de revisión
independiente. En cambio, todo el repositorio tiene un único número de versión
que identifica un estado común de todos los archivos del repositorio en cierto
punto del tiempo.
Más información: http://subversion.tigris.org/
•
SubClipse
SubClipse es un plugin que usa el software Subversion para integrar todo el
sistema de control de versiones en el entorno de desarrollo Eclipse haciendo
más compacto e intuitivo el uso de esta herramienta
Más información: http://subclipse.tigris.org/
53
Proyecto fin de carrera
•
Rubén Lozano Díaz
JDK Java SE 6
La plataforma Java es el nombre de un entorno o plataforma de computación originaria
de Sun Microsystems, capaz de ejecutar aplicaciones desarrolladas usando el Lenguaje
de programación Java u otros lenguajes que compilen a bytecode y un conjunto de
herramientas de desarrollo. En este caso, la plataforma no es un hardware específico o
un sistema operativo, sino más bien una máquina virtual encargada de la ejecución de
aplicaciones, y un conjunto de librerías estándar que ofrecen funcionalidad común.
La plataforma es así llamada la Plataforma Java (antes conocida como Plataforma Java
2), e incluye:
•
Plataforma Java, Edición Estándar (Java Platform, Standard Edition), o Java SE
(antes J2SE)
•
Plataforma Java, Edición Empresa (Java Platform, Enterprise Edition), o Java
EE (antes J2EE)
•
Plataforma Java, Edición Micro (Java Platform, Micro Edition), o Java ME
(antes J2ME)
Desde 2006, la versión actual de la Plataforma Java Standard Edition se le conoce como
Java SE 6 como versión externa, y 1.6 como versión interna. Sin embargo, se prefiere el
término versión 6. Una visión general de la multitud de tecnologías que componen la
Plataforma Java puede encontrarse en la página de documentación del JDK.
JDK(Java Development Kit) se diferencia del JRE(Java Runtime Environment) en la
cantidad de paquetes extra que se le proporcionan al desarrollador para facilitarle el
trabajo.
Más información: http://java.sun.com/javase/6/docs/
54
Proyecto fin de carrera
Rubén Lozano Díaz
7. Software Libre
7.1 Introducción al software libre
Software libre (en inglés free software) es la denominación del software que
brinda libertad a los usuarios sobre su producto adquirido y por tanto, una vez
obtenido, puede ser usado, copiado, estudiado, modificado y redistribuido
libremente. Según la Free Software Foundation, el software libre se refiere a la
libertad de los usuarios para ejecutar, copiar, distribuir, estudiar, cambiar y
mejorar el software; de modo más preciso, se refiere a cuatro libertades de los
usuarios del software: la libertad de usar el programa, con cualquier propósito;
de estudiar el funcionamiento del programa, y adaptarlo a las necesidades; de
distribuir copias, con lo que puede ayudar a otros; de mejorar el programa y
hacer públicas las mejoras, de modo que toda la comunidad se beneficie (para
la segunda y última libertad mencionadas, el acceso al código fuente es un
requisito previo).
El software libre suele estar disponible gratuitamente, o al precio de coste de la
distribución a través de otros medios; sin embargo no es obligatorio que sea
así, por ende no hay que asociar software libre a "software gratuito"
(denominado usualmente freeware), ya que, conservando su carácter de libre,
puede ser distribuido comercialmente ("software comercial"). Análogamente, el
"software gratis" o "gratuito" incluye en algunas ocasiones el código fuente; no
obstante, este tipo de software no es libre en el mismo sentido que el software
libre, a menos que se garanticen los derechos de modificación y redistribución
de dichas versiones modificadas del programa.
Tampoco debe confundirse software libre con "software de dominio público".
Éste último es aquél que no requiere de licencia, pues sus derechos de
explotación son para toda la humanidad, porque pertenece a todos por igual.
Cualquiera puede hacer uso de él, siempre con fines legales y consignando su
autoría original. Este software sería aquél cuyo autor lo dona a la humanidad o
cuyos derechos de autor han expirado, tras un plazo contado desde la muerte
55
Proyecto fin de carrera
Rubén Lozano Díaz
de éste, habitualmente 70 años. Si un autor condiciona su uso bajo una
licencia, por muy débil que sea, ya no es dominio público.
7.2 Importancia del software libre en este proyecto
De todas las herramientas usadas en este proyecto, las únicas que son
software privativo son los productos de Oracle, que aunque gratuitos, no son
libres. De hecho, es posible la descarga del código fuente de todas las otras
herramientas.
El software libre ha entrado en escena en varios momentos de los cuales la
parte mas usual ha sido la libertad de uso sin restricciones de todas las
herramientas. No obstante debemos prestar atención a dos usos
extraordinarios de las herramientas Jibble PircBot y WSXML-RPC:
•
Jibble PircBot: Esta herramienta se ha usado para programar los Bots de
ejemplo y para testear el Framework. La parte extraordinaria ha sido al
usar esta herramienta indirectamente; la arquitectura orientada a
eventos de PircBot es extremadamente útil y versátil a la hora de lanzar
operaciones. Los eventos de servidor son fundamentalmente lo mismo
que los eventos de usuario que usa PircBot por lo que hemos usado la
misma arquitectura que esta herramienta. También nos ha facilitado la
implementación de la estructura de mensajes remotos de observación.
•
WSXML-RPC: El uso ordinario de esta herramienta nos era insuficiente.
Esta herramienta puede ejecutar métodos en maquinas remotas con
validaciones de usuario. A nosotros no nos ha bastado con ello porque
para lanzar conexiones de envío de datos de observación sobre el
cliente que lo ha solicitado, necesitábamos conocer la dirección de red
del cliente y esta implementación no nos proporcionaba este servicio. Se
ha tenido que reescribir el núcleo de esta herramienta de tal manera que
para la petición de ejecución de un método validado por un usuario y
contraseña, se pudiera conocer la dirección de red que estaba
solicitando este servicio.
56
Proyecto fin de carrera
Rubén Lozano Díaz
8. Conclusiones
Actualmente la arquitectura de comunicación con IRC está acabada, así como
la estructura de mensajería remota. Se ha implementado mediante la
arquitectura de comunicación con IRC el protocolo P10 para servidores IRCHispano por lo que las pruebas se realizarán con este tipo de servidor.
En el futuro este Framework puede ser mejorado de muchísimas maneras;
añadiendo más modularidad, aumentando la seguridad del cifrado de las
contraseñas, el cifrado del transporte de datos, optimizando aun más la
arquitectura básica, convirtiendo el proyecto en un servidor de servicios
distribuido… etc. Hay muchas posibilidades y aquí se ha hecho la base y unos
ejemplos pequeños que demuestran la funcionalidad y potencia que puede
llegar a desarrollar este proyecto.
En cuanto a nivel personal, he elegido esta idea para complementar mis
estudios. Al ser un estudiante de informática de gestión apenas he tocado
redes, ni protocolos de red, ni transporte de datos y esta ha sido una manera
más que satisfactoria para introducirme en este fascinante mundo además de
todo lo expresado en las motivaciones. También me ha dado la oportunidad de
modificar y introducirme de lleno en el código de proyectos de código abierto,
he aprendido muchísimo y estas son las cosas que aunque te expliquen en
clase o de forma teórica, hasta que no te peleas con ellas las aprendes pero no
las asimilas.
57
Proyecto fin de carrera
Rubén Lozano Díaz
9. Bibliografía
Información general: http://es.wikipedia.org
Historia IRC: http://sindominio.net/quique/Traducciones/historia_irc.html
Oracle: http://www.oracle.com
Hibernate: http://www.hibernate.org
58