DeustoFacultad de IngenieríaUniversidad de DeustoIngeniaritza FakultateaDeustuko UnibertsitateaIngeniero en InformáticaInf...
Resumen        Actualmente, existe una problemática (principalmente en los móviles de últimageneración) en lo referente a ...
Descriptores        Web semántica        Proxy        Páginas web        Interpretación de datos.iv
Índice1.         Introducción______________________________________________________ 1     1.1    Acerca del proyecto _____...
4.         Justificación_____________________________________________________ 29     4.1    Beneficios técnicos __________...
8.          Conclusiones ___________________________________________________ 109     8.1     Objetivos alcanzados ________...
12.21        Licencias (Ver 10) _________________________________________________ 148   12.22        Manual de usuario (Ve...
Ilustración 5-5: Flujo de Django-Revproxy --------------------------------------------------------------------------------...
Ilustración 13-31: Scripts de cada página del proxy -------------------------------------------------------------------- 1...
Código 5-20: Ejemplo Json ------------------------------------------------------------------------------------------------...
Código 13-5: Instalación Beautiful Soup ----------------------------------------------------------------------------------...
PROYECTO FIN DE CARRERA                                                        1. INTRODUCCIÓN1.1 ACERCA DEL PROYECTO     ...
1. INTRODUCCIÓN       Definición del proyecto: Se explica qué es lo que se pretende conseguir con        este proyecto, e...
PROYECTO FIN DE CARRERA                                  2. DEFINICIÓN DEL PROYECTO2.1 OBJETIVOS         El proyecto está ...
2. DEFINICIÓN DEL PROYECTO       Desarrollar un backend mediante el cual se pueda administrar y depurar        metadatos ...
PROYECTO FIN DE CARRERA       Realización de una documentación donde se explique el funcionamiento de la        herramien...
2. DEFINICIÓN DEL PROYECTO           o     Administrador de las páginas que maneja el servidor proxy.           o     Admi...
PROYECTO FIN DE CARRERA        del problema. Es importante tener en cuenta la flexibilidad que se desea        conseguir, ...
2. DEFINICIÓN DEL PROYECTO                                 Ilustración 2-1: Tabla de tareasPor otra parte, el diagrama de ...
PROYECTO FIN DE CARRERAIlustración 2-2: Diagrama de Gantt                                                          9
2. DEFINICIÓN DEL PROYECTO2.5 ORGANIZACIÓN Y EQUIPO      La organización del proyecto está formada por un comité de direcc...
PROYECTO FIN DE CARRERA              Se organizarán reuniones esporádicas (mensuales) para la toma de       decisiones, as...
2. DEFINICIÓN DEL PROYECTO2.6 PRESUPUESTO       Las horas han sido variables durante el transcurso del proyecto, peroaprox...
PROYECTO FIN DE CARRERA   Software       o   Sistema Operativo GNU/Linux (distribuciones Arch Linux y Slackware).       o...
PROYECTO FIN DE CARRERA                                                  3. CONCEPTOS BÁSICOS3.1 PROXY        Un proxy per...
3. CONCEPTOS BÁSICOS                Un proxy abierto u open proxy es un servidor proxy de reenvío que es         accesible...
PROYECTO FIN DE CARRERA           o   Compresión           o   Spoon feeding           o   Seguridad           o   Extrane...
3. CONCEPTOS BÁSICOSnosotros no reconocemos o percibimos, pero que ciertas herramientas software (talescomo los buscadores...
PROYECTO FIN DE CARRERA                      Ilustración 3-4: Estructura de la web semántica       Para obtener una adecua...
3. CONCEPTOS BÁSICOS3.3 ONTOLOGÍAS       Dentro de la informática cuando nos referimos a ontologías, se hace referenciaa l...
PROYECTO FIN DE CARRERA3.4 SPARQL       SPARQL (SPARQL Protocol and RDF Query Language) es un lenguajeestandarizado para l...
3. CONCEPTOS BÁSICOS      1. Utilizar URIs para identificar los recursos publicados en la Web.      2. Aprovechar el HTTP ...
PROYECTO FIN DE CARRERAcual se define el lenguaje. Específicamente, las expresiones regulares se construyenutilizando los ...
3. CONCEPTOS BÁSICOS        PCRE: biblioteca de ExReg para C, C++ y otros lenguajes que puedan utilizar         bibliotec...
PROYECTO FIN DE CARRERAre{ n, m}     De n a m ocurrencias   a| b       Aob   (re)       Agrupa expresiones regulares      ...
3. CONCEPTOS BÁSICOS          S            Asocia no espacios en blanco          d            Asocia dígitos. Equivalente ...
PROYECTO FIN DE CARRERA       GRDDL es una forma de indicar una transformación, comúnmente medianteXSLT, de un documento X...
3. CONCEPTOS BÁSICOS                       Código 3-4: Profile de GRDDL dentro de hcardY por último: <p>Use of this profil...
PROYECTO FIN DE CARRERA                                                      4. JUSTIFICACIÓN       La realización de este...
PROYECTO FIN DE CARRERA                     5. INVESTIGACIÓN EN TECNOLOGÍAS5.1 VISIÓN GENERAL       En este capítulo se va...
5. INVESTIGACIÓN EN TECNOLOGÍAS5.2.1.1        Tipos de datos       Los tipos de datos que existen en este lenguaje, estos ...
PROYECTO FIN DE CARRERA5.2.1.2    Ejemplo práctico       A modo de ejemplo práctico, en las siguientes líneas se va a most...
5. INVESTIGACIÓN EN TECNOLOGÍAS                    Código 5-3 Ejemplo de un script (programa) en Python        Finalmente,...
PROYECTO FIN DE CARRERA5.2.2    Django                            Ilustración 5-2: Logo Django       Después de haber eleg...
5. INVESTIGACIÓN EN TECNOLOGÍAS       La meta fundamental de Django es facilitar la creación de sitios web complejos.Djang...
PROYECTO FIN DE CARRERA       Para poder usar Django, tan sólo es necesario tener instalado Python. Conesto, Django podría...
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Memoria pfc,  Metaproxy documentation
Upcoming SlideShare
Loading in …5
×

Memoria pfc, Metaproxy documentation

1,379 views

Published on

Documentation of our (@sharem and @sLoK69) final year project in the university of Deusto (Computer engineering)

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,379
On SlideShare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
7
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Memoria pfc, Metaproxy documentation

  1. 1. DeustoFacultad de IngenieríaUniversidad de DeustoIngeniaritza FakultateaDeustuko UnibertsitateaIngeniero en InformáticaInformatikako IngeniariaProyecto fin de carreraKarrera amaierako proiektua
  2. 2. Resumen Actualmente, existe una problemática (principalmente en los móviles de últimageneración) en lo referente a los datos que contienen las páginas web: muchasaplicaciones tanto móviles como de escritorio, e incluso otras páginas web (como porejemplo, buscadores) requieren unos datos “extra” de las páginas web, para larealización de una serie de funcionalidades específicas. A estos datos “extra” se lesdenomina metadatos y en la actualidad, muchas veces estos datos no son visibles asimple vista o no son presentados visualmente a los humanos de manera adecuada. El objetivo de este proyecto es el de crear un servidor proxy que permita quelos metadatos (datos extra) de las páginas web convencionales puedan servisualizados de manera adecuada para los seres humanos mediante el uso de una delas tecnologías de moda en los últimos tiempos: la Web Semántica. El servidor proxy hará de intermediario entre el cliente que desea la página weby el servidor que le proporciona dicha página web al cliente. Gracias al servidor proxy,el cliente obtendrá una versión ligeramente modificada de la página web solicitada. Elservidor, aparte de obtener una copia de la página solicitada, extraerá de ella losmetadatos y los transformará en un formato adecuado para su posterior visualizaciónen formatos entendibles como XML o grafos. Es más, el servidor, también tendrá lacapacidad de insertar metadatos en las propias páginas si así se desea. El manejo del servido proxy se realizará a través de un portal webimplementado mediante el framework de desarrollo web de código abierto Django, porlo que el usuario del proxy únicamente deberá de disponer de un navegador web paraacceder a éste. Para la configuración del servidor proxy se dispondrá de un panel de control alcual sólo podrán acceder los administradores a través del portal mencionado en elanterior párrafo. Mediante él, se podrán insertar datos en la base de datos, añadirnuevas páginas al servidor para ser tratadas y hacer consultas especiales (SPARQL)sobre los metadatos almacenados previamente extraídos de las páginas solicitadas.Asimismo, también se podrá cambiar el comportamiento del servidor proxy, es decir, apesar de que por defecto el proxy esté configurado para la extracción/manejo demetadatos, los usuarios podrán subir al servidor scripts en Python personalizados quehagan que el servidor realice otras actividades como puede ser la traducción o lamodificación del aspecto de una página web o como se ha mencionado anteriormente,la propia inserción de metadatos en páginas web tradicionales. iii
  3. 3. Descriptores  Web semántica  Proxy  Páginas web  Interpretación de datos.iv
  4. 4. Índice1. Introducción______________________________________________________ 1 1.1 Acerca del proyecto ___________________________________________________ 1 1.2 Acerca de la documentación ____________________________________________ 12. Definición del proyecto _____________________________________________ 3 2.1 Objetivos ___________________________________________________________ 3 2.2 Alcance _____________________________________________________________ 4 2.2.1 Alcance del proyecto _______________________________________________________ 4 2.2.2 Alcance de la investigación __________________________________________________ 4 2.2.3 Alcance de la documentación ________________________________________________ 4 2.2.4 Alcance de la herramienta ___________________________________________________ 5 2.3 Producto final ________________________________________________________ 5 2.4 Descripción de la realización ____________________________________________ 6 2.4.1 Método de desarrollo: ______________________________________________________ 6 2.4.2 Tareas principales: _________________________________________________________ 7 2.5 Organización y equipo ________________________________________________ 10 2.6 Presupuesto ________________________________________________________ 12 2.7 Condiciones de ejecución _____________________________________________ 123. Conceptos básicos ________________________________________________ 15 3.1 Proxy ______________________________________________________________ 15 3.1.1 Tipos ___________________________________________________________________ 15 3.1.2 Funcionamiento __________________________________________________________ 17 3.2 Web Semántica _____________________________________________________ 17 3.2.1 Definición _______________________________________________________________ 17 3.2.2 Utilidades _______________________________________________________________ 17 3.2.3 Funcionamiento __________________________________________________________ 18 3.3 Ontologías _________________________________________________________ 20 3.4 SPARQL ____________________________________________________________ 21 3.5 Linked Data ________________________________________________________ 21 3.6 Expresiones regulares ________________________________________________ 22 3.7 GRDDL_____________________________________________________________ 26 3.7.1 Ejemplo con XHTML _______________________________________________________ 27 3.7.2 Microformatos ___________________________________________________________ 27 v
  5. 5. 4. Justificación_____________________________________________________ 29 4.1 Beneficios técnicos ___________________________________________________ 29 4.2 Beneficios económicos ________________________________________________ 295. Investigación en tecnologías _______________________________________ 31 5.1 Visión general _______________________________________________________ 31 5.2 Recursos principales __________________________________________________ 31 5.2.1 Python _________________________________________________________________ 31 5.2.2 Django _________________________________________________________________ 35 5.2.3 Django-Revproxy _________________________________________________________ 40 5.2.4 Redland ________________________________________________________________ 43 5.2.5 Git ____________________________________________________________________ 51 5.3 Recursos ___________________________________________________________ 57 5.3.1 Restkit _________________________________________________________________ 57 5.3.2 LXML __________________________________________________________________ 58 5.3.3 Pygments _______________________________________________________________ 59 5.3.4 Python Graph & Graphviz __________________________________________________ 59 5.3.5 Beautiful Soup ___________________________________________________________ 636. Desarrollo ______________________________________________________ 65 6.1 Estructura del proyecto _______________________________________________ 65 6.1.1 Portal Web (Django) ______________________________________________________ 65 6.1.2 Proxy __________________________________________________________________ 81 6.1.3 Scripts _________________________________________________________________ 84 6.2 API ________________________________________________________________ 98 6.2.1 ModifyBodyBase _________________________________________________________ 98 6.2.2 Utilidades ______________________________________________________________ 1007. Usos alternativos _______________________________________________ 103 7.1 Traducción ________________________________________________________ 103 7.1.1 Google API _____________________________________________________________ 103 7.2 Discapacitados _____________________________________________________ 105 7.3 Analizador de código malicioso ________________________________________ 105 7.4 Guardar datos______________________________________________________ 105 7.5 Notificaciones ______________________________________________________ 106 7.5.1 Redes sociales __________________________________________________________ 106 7.5.2 E-mails ________________________________________________________________ 106 7.5.3 SMS __________________________________________________________________ 107 7.6 Testeo de páginas web_______________________________________________ 107 7.6.1 Diseño ________________________________________________________________ 107 7.6.2 Actualizaciones _________________________________________________________ 107vi
  6. 6. 8. Conclusiones ___________________________________________________ 109 8.1 Objetivos alcanzados ________________________________________________ 109 8.2 Consideraciones ____________________________________________________ 109 8.3 Posibles mejoras futuras _____________________________________________ 1109. Agradecimientos ________________________________________________ 11310. Licencias _______________________________________________________ 115 10.1 Imágenes________________________________________________________ 115 10.2 Documentación __________________________________________________ 115 10.3 Proyecto ________________________________________________________ 120 10.4 Revproxy ________________________________________________________ 13211. Glosario _______________________________________________________ 13312. Bibliografía ____________________________________________________ 145 12.1 Proxys (Ver 3.1) __________________________________________________ 145 12.2 Web Semántica (Ver 3.2) ___________________________________________ 145 12.3 Ontologías (Ver 3.3) _______________________________________________ 145 12.4 SPARQL (Ver 3.4) _________________________________________________ 145 12.5 Linked Data (Ver 3.5) ______________________________________________ 146 12.6 Expresiones regulares (Ver 3.6) ______________________________________ 146 12.7 GRDDL (Ver 3.7) __________________________________________________ 146 12.8 Python (Ver 5.2.1) ________________________________________________ 146 12.9 Django (Ver 5.2.2)_________________________________________________ 146 12.10 Django revproxy (Ver 5.2.3) _________________________________________ 147 12.11 Redland (Ver 5.2.4)________________________________________________ 147 12.12 Git (Ver 5.2.5) ____________________________________________________ 147 12.13 Restkit (Ver 5.3.1) _________________________________________________ 147 12.14 LXML (Ver 5.3.2) __________________________________________________ 147 12.15 Pygments (Ver 5.3.3) ______________________________________________ 147 12.16 Python graph (Ver 5.3.4) ___________________________________________ 147 12.17 Beautiful Soup (Ver 5.3.5) __________________________________________ 148 12.18 Desarrollo (Ver 6) _________________________________________________ 148 12.19 Usos alternativos (Ver 7) ___________________________________________ 148 12.20 Conclusiones (Ver 8) _______________________________________________ 148 vii
  7. 7. 12.21 Licencias (Ver 10) _________________________________________________ 148 12.22 Manual de usuario (Ver 13) _________________________________________ 148 12.23 Glosario (Ver 11) __________________________________________________ 149 12.24 Otros ___________________________________________________________ 14913. Manual de usuario ______________________________________________ 151 13.1 Instalación _______________________________________________________ 151 13.1.1 Requisitos primarios _____________________________________________________ 151 13.1.2 Requisitos _____________________________________________________________ 151 13.2 Entorno de producción _____________________________________________ 155 13.2.1 Requisitos _____________________________________________________________ 155 13.2.2 Se presupone ___________________________________________________________ 155 13.2.3 Configurar Nginx ________________________________________________________ 155 13.2.4 Añadir configuración de Django uWSGI ______________________________________ 156 13.2.5 Script para hacer deploy de aplicaciones Django_______________________________ 157 13.2.6 Script de ejecucucíon uWSGI ______________________________________________ 157 13.2.7 Configuración Django ____________________________________________________ 159 13.2.8 Crear base de datos para Django ___________________________________________ 159 13.2.9 Ejecución en modo producción ____________________________________________ 159 13.3 Uso ____________________________________________________________ 161 13.3.1 Página principal _________________________________________________________ 161 13.3.2 Sección administración de la página web ____________________________________ 162 13.3.3 Sección Administrador proxy ______________________________________________ 164 13.3.4 Ejemplos sobre el proyecto _______________________________________________ 176Tabla de IlustracionesIlustración 2-1: Tabla de tareas ------------------------------------------------------------------------------------------------- 8Ilustración 2-2: Diagrama de Gantt -------------------------------------------------------------------------------------------- 9Ilustración 2-3: Esquema organizativo -------------------------------------------------------------------------------------- 10Ilustración 3-1: Ilustración de un forward proxy -------------------------------------------------------------------------- 15Ilustración 3-2: Ilustración de un proxy abierto --------------------------------------------------------------------------- 16Ilustración 3-3: Ilustración de un proxy inverso --------------------------------------------------------------------------- 16Ilustración 3-4: Estructura de la web semántica-------------------------------------------------------------------------- 19Ilustración 3-5: Ejemplo de ontología --------------------------------------------------------------------------------------- 20Ilustración 3-6: Conjunto de datos interconectados entre sí que componen la "Nube de Linked Data" --- 22Ilustración 5-1: Logo de Python ----------------------------------------------------------------------------------------------- 31Ilustración 5-2: Logo Django --------------------------------------------------------------------------------------------------- 35Ilustración 5-3: Flujo ------------------------------------------------------------------------------------------------------------- 37Ilustración 5-4: Estructura de un proyecto en Django------------------------------------------------------------------- 38viii
  8. 8. Ilustración 5-5: Flujo de Django-Revproxy ---------------------------------------------------------------------------------- 41Ilustración 5-6: Carpetas y archivos de Revproxy ------------------------------------------------------------------------- 43Ilustración 5-7: Logo Git --------------------------------------------------------------------------------------------------------- 51Ilustración 5-8: Estados de trabajo con Git --------------------------------------------------------------------------------- 54Ilustración 5-9: Commits y branchs del proyecto visualizados en gitk----------------------------------------------- 55Ilustración 5-10: Logo Github -------------------------------------------------------------------------------------------------- 55Ilustración 5-11: Proyecto hospedado en Github ------------------------------------------------------------------------- 56Ilustración 5-12: Branchs del proyecto en Github ------------------------------------------------------------------------- 57Ilustración 5-13: Grafo creado con Graphviz ------------------------------------------------------------------------------- 61Ilustración 6-1: Estructura del proyecto ------------------------------------------------------------------------------------- 65Ilustración 6-2: Estructura de un paquete HTTP --------------------------------------------------------------------------- 83Ilustración 6-3: Algunos argumentos de la cabecera de un paquete HTTP ---------------------------------------- 83Ilustración 7-1: Clave de la API de Google -------------------------------------------------------------------------------- 104Ilustración 7-2: Panel de control de API de Google --------------------------------------------------------------------- 104Ilustración 13-1: Página principal ------------------------------------------------------------------------------------------- 161Ilustración 13-2: Menú de la página principal --------------------------------------------------------------------------- 161Ilustración 13-3: Páginas registradas en el proxy ----------------------------------------------------------------------- 162Ilustración 13-4: Acceso al repositorio online con el código fuente ------------------------------------------------ 162Ilustración 13-5: Login de la administración de la web---------------------------------------------------------------- 162Ilustración 13-6: Pantalla principal del panel de adminsitración de la web ------------------------------------- 163Ilustración 13-7: Añadir nuevo usuarios ----------------------------------------------------------------------------------- 163Ilustración 13-8: Lista de usuarios ------------------------------------------------------------------------------------------ 164Ilustración 13-9: Zoom de la lista de usuarios --------------------------------------------------------------------------- 164Ilustración 13-10: Menú de administración del proxy (Manager) -------------------------------------------------- 165Ilustración 13-11: Login administrador proxy ---------------------------------------------------------------------------- 165Ilustración 13-12: Iconos del menú del Manager ----------------------------------------------------------------------- 166Ilustración 13-13: RDF Uploader -------------------------------------------------------------------------------------------- 166Ilustración 13-14: Subir archivo RDF desde la máquina local -------------------------------------------------------- 167Ilustración 13-15: Selección del archivo RDF local ---------------------------------------------------------------------- 167Ilustración 13-16: Descargar archivo RDF--------------------------------------------------------------------------------- 167Ilustración 13-17: Selección de la base de datos donde almacenar el archivo RDF ---------------------------- 168Ilustración 13-18: Página de inserción en base de datos correcta ------------------------------------------------- 168Ilustración 13-19: Página para la inserción de ontologías ------------------------------------------------------------ 169Ilustración 13-20: Inserción del nombre de la ontología -------------------------------------------------------------- 169Ilustración 13-21: Inserción del enlace a la ontología ----------------------------------------------------------------- 169Ilustración 13-22: Listado de ontologías almacenadas ---------------------------------------------------------------- 170Ilustración 13-23: Consultas SPARQL --------------------------------------------------------------------------------------- 170Ilustración 13-24: Selección de la base de datos en la que realizar la consulta--------------------------------- 171Ilustración 13-25: Selección del formato para los resultados -------------------------------------------------------- 171Ilustración 13-26: Caja de texto para la query SPARQL --------------------------------------------------------------- 171Ilustración 13-27: Resultado de la consulta (query) en la base de datos ----------------------------------------- 172Ilustración 13-28: Administración de scripts ----------------------------------------------------------------------------- 172Ilustración 13-29: Selección del archivo del script ---------------------------------------------------------------------- 173Ilustración 13-30: Selección de la página a la que pertenecerá el script ----------------------------------------- 173 ix
  9. 9. Ilustración 13-31: Scripts de cada página del proxy -------------------------------------------------------------------- 173Ilustración 13-32: Visualizador de scripts---------------------------------------------------------------------------------- 174Ilustración 13-33: Administrador de páginas web del proxy --------------------------------------------------------- 174Ilustración 13-34: Identificador de la página ----------------------------------------------------------------------------- 175Ilustración 13-35: Enlace de la página web ------------------------------------------------------------------------------- 175Ilustración 13-36: Listado de las páginas registradas en el proxy -------------------------------------------------- 175Ilustración 13-37: Página con un visualizador de tweets -------------------------------------------------------------- 176Ilustración 13-38: Página personal de David Buján --------------------------------------------------------------------- 177Ilustración 13-39: Página dipina --------------------------------------------------------------------------------------------- 177Ilustración 13-40: Vista de RDF en XML ------------------------------------------------------------------------------------ 178Ilustración 13-41: Grafo a partir del RDF/XML --------------------------------------------------------------------------- 178Ilustración 13-42: Demostración de GRDDL ------------------------------------------------------------------------------ 179Ilustración 13-43: XML de RDF ----------------------------------------------------------------------------------------------- 180Ilustración 13-44: Grafo de RDF ---------------------------------------------------------------------------------------------- 180Ilustración 13-45: XML generado a partir de GRDDL ------------------------------------------------------------------- 181Ilustración 13-46: Grafo a partir de RDF/XML del GRDDL ------------------------------------------------------------- 181Tabla de bloques de código fuenteCódigo 3-1: Ejemplo de expresión regular en Python ------------------------------------------------------------------- 26Código 3-2: Declaración de transformación GRDDL en XHTML------------------------------------------------------- 27Código 3-3: Declaración de transformación GRDDL para hcard con Microformatos --------------------------- 27Código 3-4: Profile de GRDDL dentro de hcard ---------------------------------------------------------------------------- 28Código 3-5: Datos de hcard conteninedo el XSL para transformar microformatos hcard en GRDDL ------- 28Código 5-1: Ejemplo de una función en Python --------------------------------------------------------------------------- 33Código 5-2: Ejemplo de una clase en Python ------------------------------------------------------------------------------ 33Código 5-3 Ejemplo de un script (programa) en Python ---------------------------------------------------------------- 34Código 5-4 Resultado del ejemplo anterior -------------------------------------------------------------------------------- 34Código 5-5: Ejemplo de fichero urls.py -------------------------------------------------------------------------------------- 39Código 5-6: Ejemplo models.py ----------------------------------------------------------------------------------------------- 39Código 5-7: Traducción SQL de models.py --------------------------------------------------------------------------------- 39Código 5-8: Ejemplo de views.py---------------------------------------------------------------------------------------------- 40Código 5-9: Asignación de direcciones proxy ------------------------------------------------------------------------------ 42Código 5-10: Asignación de urls en Django -------------------------------------------------------------------------------- 42Código 5-11: Ejemplo RDF/XML ----------------------------------------------------------------------------------------------- 45Código 5-12: Ejemplo N-Quads ------------------------------------------------------------------------------------------------ 45Código 5-13: Ejemplo N-Triples ----------------------------------------------------------------------------------------------- 45Código 5-14: Ejemplo Turtle --------------------------------------------------------------------------------------------------- 46Código 5-15: Ejemplo TRiG ----------------------------------------------------------------------------------------------------- 46Código 5-16: Ejemplo RSS (con RDF) ----------------------------------------------------------------------------------------- 47Código 5-17: Ejemplo GRDDL (Sobre HTML) ------------------------------------------------------------------------------- 47Código 5-18: Ejemplo RDFa (Sobre HTML) --------------------------------------------------------------------------------- 48Código 5-19: Ejemplo Atom 1.0 ----------------------------------------------------------------------------------------------- 49x
  10. 10. Código 5-20: Ejemplo Json ------------------------------------------------------------------------------------------------------ 49Código 5-21: Ejemplo DOT (Grafos) ------------------------------------------------------------------------------------------ 49Código 5-22: Ejemplo 1º de uso básico con restkit ----------------------------------------------------------------------- 58Código 5-23: Ejemplo 2º de uso básico con restkit ----------------------------------------------------------------------- 58Código 5-24: Ejemplo de lenguaje DOT en Graphviz --------------------------------------------------------------------- 60Código 5-25: Código de ejemplo de Python Graph ----------------------------------------------------------------------- 63Código 6-1: urls.py ---------------------------------------------------------------------------------------------------------------- 67Código 6-2: manager/urls.py --------------------------------------------------------------------------------------------------- 68Código 6-3: settings.py ----------------------------------------------------------------------------------------------------------- 69Código 6-4: Fragmento de código de urls.py ------------------------------------------------------------------------------- 69Código 6-5: Fragmento de código de la función de manager/rdf ---------------------------------------------------- 70Código 6-6: código del método de descarga dentro de utils ----------------------------------------------------------- 71Código 6-7: Código del método para tratar las subidas locales de RDF -------------------------------------------- 72Código 6-8: Código para el almacenaje de RDFs en la base de datos ----------------------------------------------- 72Código 6-9: Modelo de base de datos para las ontologías en Django ---------------------------------------------- 73Código 6-10: Método que interactúa con las ontologías de la BD --------------------------------------------------- 74Código 6-11: Método encargado de la página de queries -------------------------------------------------------------- 75Código 6-12: Método encargado de la ejecución de queries SPARQL ----------------------------------------------- 75Código 6-13: Método para añadir una web proxy ------------------------------------------------------------------------ 76Código 6-14: Método para la eliminación de páginas web proxy ---------------------------------------------------- 77Código 6-15: Método para la subida de scripts al servidor ------------------------------------------------------------- 78Código 6-16: Método para la visualización de los scripts --------------------------------------------------------------- 78Código 6-17: Fragmento de código de urls.py ----------------------------------------------------------------------------- 79Código 6-18: Fragmento de código de /manager/urls.py -------------------------------------------------------------- 79Código 6-19: manager/views.py----------------------------------------------------------------------------------------------- 80Código 6-20: templates/registration/login.html -------------------------------------------------------------------------- 81Código 6-21: ModifyBody.py de la página dbujan ------------------------------------------------------------------------ 87Código 6-22: ModifyBody.py de la página slok ---------------------------------------------------------------------------- 90Código 6-23: Comienzo del fichero ModifyBody.py por defecto ------------------------------------------------------ 91Código 6-24: Método de la lógica en ModifyBody.py por defecto --------------------------------------------------- 92Código 6-25: Método para modificación de la cabecera del HTML que está en ModifyBody.py ------------- 93Código 6-26: Método para creación de todas las pestañas en ModifyBody.py ----------------------------------- 95Código 6-27: Creación de una única pestaña en ModifyBody.py ----------------------------------------------------- 96Código 6-28: Métodos para parser GRDDL en ModifyBody.py -------------------------------------------------------- 97Código 6-29: Método que modifica el cuerpo del HTML en ModifyBody.py --------------------------------------- 98Código 6-30: ModifyBodyBase.py --------------------------------------------------------------------------------------------- 99Código 6-31: Reimplementación simple para un script del proxy -------------------------------------------------- 100Código 6-32: Importar métodos del módulo Db ------------------------------------------------------------------------- 101Código 6-33: Importar métodos del módulo Rdf ------------------------------------------------------------------------ 101Código 6-34: Importar métodos del módulo utils ----------------------------------------------------------------------- 102Código 13-1: Instalación de setuptools y pip ----------------------------------------------------------------------------- 152Código 13-2: Instalación Django -------------------------------------------------------------------------------------------- 152Código 13-3: Instalación Restkit --------------------------------------------------------------------------------------------- 152Código 13-4: Instalación Pygments ----------------------------------------------------------------------------------------- 152 xi
  11. 11. Código 13-5: Instalación Beautiful Soup ----------------------------------------------------------------------------------- 152Código 13-6: Instalación Lxml ------------------------------------------------------------------------------------------------ 152Código 13-7: Obtención del código fuente de Graphviz --------------------------------------------------------------- 153Código 13-8: Instalación de Graphviz--------------------------------------------------------------------------------------- 153Código 13-9: Instalación Python-graphviz--------------------------------------------------------------------------------- 153Código 13-10: Instalación Raptor -------------------------------------------------------------------------------------------- 154Código 13-11: Instalación Rasqal -------------------------------------------------------------------------------------------- 154Código 13-12: Instalación LibRDF -------------------------------------------------------------------------------------------- 154Código 13-13: Imstalación Python Redland bindings------------------------------------------------------------------- 154Código 13-14: Archivo de configuración de Nginx ---------------------------------------------------------------------- 156Código 13-15: Configuración de Django para uWSGI ------------------------------------------------------------------ 156Código 13-16: Script para deploy de aplicaciones Django con uWSGI --------------------------------------------- 157Código 13-17: Script de comando uWSGI --------------------------------------------------------------------------------- 159Código 13-18: Usuario y clave de la BD en settings.py----------------------------------------------------------------- 159Código 13-19: Usuarío y clave de la BD en manager/views.py ------------------------------------------------------ 159Código 13-20: Comando para la creación de las tablas de Django en la BD ------------------------------------- 159Código 13-21: Comando para arrancar demonio de Nginx ----------------------------------------------------------- 160Código 13-22: Comando para arrancar script de deploy -------------------------------------------------------------- 160Código 13-23: Ejemplo de query SPARQL ---------------------------------------------------------------------------------- 171xii
  12. 12. PROYECTO FIN DE CARRERA 1. INTRODUCCIÓN1.1 ACERCA DEL PROYECTO En la actualidad, la Web está llena de páginas dispersas por todo el planeta, dediferentes sitios y con contenido diverso y variado. Por ello, cada vez es más complejounificar, encontrar, organizar y obtener datos de ellas. La Web Semántica intenta hacer todo esto más fácil proporcionándonosnuevas tecnologías y herramientas como son los RDF, Ontologías, EndpointsSPARQL, Linked Data, etc. Para ello, las páginas actuales deben actualizarse y sermodificadas de forma que puedan utilizar toda la potencia de la Web Semántica, cuyoobjetivo no es más que el de crear una Web (en su totalidad) llena de metadatos. Este proyecto está orientado hacia la Web Semántica. Es decir, trabaja conpáginas web que estén preparadas para trabajar con metadatos, les extrae esosmetadatos y los representa de forma visible al ojo humano. Sin embargo, debido al diseño flexible del proyecto, éste puede usarse a su vezpara trabajar de otras formas que no tengan que ver con los metadatos. Una breveexplicación de esto último es que al tratarse el proyecto de un proxy que modifica elcomportamiento de la página que se solicita, por defecto crea una visualizaciónadecuada de los metadatos. Sin embargo, es posible modificar este últimocomportamiento y hacer que en vez de visualizar metadatos realice otras utilidades,como por ejemplo, cambiar el aspecto visual de una página web.1.2 ACERCA DE LA DOCUMENTACIÓN Esta documentación pretende ser un punto de referencia para interiorizar yentender el proyecto, desde los pilares más básicos como es el diseño y la idea en sí(incluyendo una explicación de ciertos conceptos asociados al proyecto como son laWeb Semántica y las Ontologías), hasta la planificación de cómo se ha desarrollado.Asimismo, también cuenta al final con el anexo “Manual de Usuario” donde seexplicará detalladamente el uso de la aplicación web para el manejo de suadministración.Los diferentes capítulos de los que consta esta memoria son: 1
  13. 13. 1. INTRODUCCIÓN  Definición del proyecto: Se explica qué es lo que se pretende conseguir con este proyecto, es decir su objetivo, así como su alcance.  Justificación: Cómo se justifica el desarrollo del proyecto. La razón por la cual se ha realizado, así como los beneficios que puede aportar.  Conceptos básicos: Definición y explicación de conceptos que ayudarán a entender la documentación en su totalidad.  Recursos utilizados: Qué recursos han sido utilizados para el desarrollo, puesta en marcha y pruebas del proyecto.  Diseño del proyecto: Una explicación a grandes rasgos de cómo está organizado el proyecto, las ventanas que utiliza, etc. (mencionar que se explicarán en más profundidad más adelante, en el anexo “Manual de Usuario”).  Desarrollo del proyecto: Cuál ha sido el desarrollo, cómo se ha organizado el proyecto en el ámbito del desarrollo, componentes, etc.  Usos alternativos: Qué usos alternativos se le pueden dar al proyecto además del cual para el que ha sido creado en un primer momento, es decir, la extracción/inserción de metadatos en páginas web.  Planificación: Cuál ha sido el diario de planificación, diagramas de Gantt, plazos establecidos, calendarios, etc.  Conclusión: Conclusión global del proyecto, tanto en aprendizaje propio a lo largo del recorrido como el aporte que supone el proyecto a la Web Semántica.  Manual de usuario: Documento que explica cómo hacer uso de las herramientas desarrolladas a nivel de usuario.2
  14. 14. PROYECTO FIN DE CARRERA 2. DEFINICIÓN DEL PROYECTO2.1 OBJETIVOS El proyecto está principalmente orientado a solucionar problemas que tienenque ver con los metadatos, pese a que como veremos más adelante, también puedaser utilizado con otros fines. Uno de los objetivos es el de hacer que una página sinmetadatos pueda ser enriquecida con ellos. Debido a que el servidor se trata de unservido proxy, en la práctica la página original no contendría los metadatosintroducidos, sino que el proxy al cual el usuario hace la petición de enriquecer lapágina indicada por él/ella, tras combinar la página original con los metadatos ainsertar (que previamente han sido introducidos y almacenados en el propio servidorproxy) devolverá al usuario una página casi idéntica a la original solo que enriquecidacon metadatos. Por otra parte, también existe el problema de que a pesar de que algunaspáginas tienen metadatos, estos no están adecuadamente representados visualmentedificultando su identificación y comprensión para los humanos. Por ello, otro de losobjetivos que se persiguen es el de poder extraer los metadatos de las páginas yposteriormente, tras generar una página casi idéntica a la original, representarlosvisualmente en ella en un formato más cómodo de visualizar por el ser humano(concretamente en formato XML y también a modo de grafo).Así expuesta la situación, este proyecto persigue los siguientes objetivos:  Investigación de las posibilidades que ofrece la Web Semántica en páginas sin metadatos.  Investigación de las posibilidades que ofrece la Web Semántica en las páginas con metadatos.  Documentación sobre el proyecto para posterior aprendizaje y puesta en funcionamiento.  Extracción de metadatos en páginas semantizadas.  Añadir metadatos a páginas semantizadas y/o sin semantizar.  Creación de una estructura flexible del servidor proxy donde el comportamiento por defecto de éste (extracción y añadido de metadatos) no sea la única posibilidad. 3
  15. 15. 2. DEFINICIÓN DEL PROYECTO  Desarrollar un backend mediante el cual se pueda administrar y depurar metadatos del proxy.  Desarrollar una pequeña API para trabajar con metadatos.2.2 ALCANCE2.2.1 Alcance del proyectoLos límites generales del proyecto son:  Realización de una investigación sobre las tecnologías que mejor se adapten a las necesidades del proyecto y posterior documentación.  Implementación del proyecto con su backend de administración y depuración, así como el servidor proxy.  Implementación de varios scripts para diferentes páginas como prueba de concepto y la redacción de una documentación adecuada que describa el proyecto.2.2.2 Alcance de la investigaciónLos límites de la investigación son:  Realización de una investigación sobre las tecnologías utilizadas en la Web Semántica para la descripción de los contenidos, como RDF, OWL, RDFa o GRDDL, además de SPARQL, el lenguaje de consulta más utilizado dentro de la Web Semántica.  Realización de una investigación sobre los pilares de la infraestructura, como son el lenguaje de programación Python, el framework para la creación del portal Django y las diferentes librerías usadas, las cuales se describirán más adelante.2.2.3 Alcance de la documentaciónLos límites de la documentación son:  Realización de una documentación donde se expliquen los conceptos básicos necesarios para entender el proyecto, la herramienta (el servidor proxy) y la documentación.4
  16. 16. PROYECTO FIN DE CARRERA  Realización de una documentación donde se explique el funcionamiento de la herramienta (el servidor proxy).  Realización de una documentación donde se explique el proceso, así como las diferentes tecnologías/herramientas utilizadas para el desarrollo del proyecto.2.2.4 Alcance de la herramienta Este proyecto tiene un alcance un tanto global, ya que ha sido diseñado deforma que resulte lo más flexible posible. Esto último, hace posible que la mayor partelas páginas existentes puedan aprovecharse de esta herramienta. Sin embargo, parala realización de las pruebas de concepto pertinentes hemos seleccionado y hechouso de una serie de páginas específicas:  Página personal de Dr. Diego López de Ipiña: Esta página constituye la página principal sobre la cual se ha experimentado con la extracción, manejo y representación tanto en XML como en forma de grafo de metadatos. Más específicamente, se ha realizado una extracción de RDFa mediante GRDDL, así como un análisis de archivos RDFa.  Página personal de David Bujan: En la página personal de David Buján se ha realizado una prueba de concepto para demostrar que este proyecto no sólo vale para el añadido, manejo y extracción de metadatos, sino para todo lo que se nos pueda ocurrir como cambiar el estilo de una página por completo.  Servidor propio para pruebas: Al igual que la página de David Buján, en ésta se han hecho pruebas diferentes a las de extracción/manejo de metadatos. Sin embargo, en un punto del desarrollo también nos sirvió para experimentar con RDFa y GRDDL, así como con diferentes ontologías.2.3 PRODUCTO FINAL Este proyecto va a dar lugar a un producto final que a su vez, se compone deuna serie de productos finales o herramientas:  Backend: o Administrador de usuarios. 5
  17. 17. 2. DEFINICIÓN DEL PROYECTO o Administrador de las páginas que maneja el servidor proxy. o Administrador de scripts.  Depuración: o Administrador de RDFs. o Administrador de Ontologías. o Consultas SPARQL.  Proxy: o Script por defecto para la extracción de metadatos (de modo que el comportamiento por defecto de servidor proxy sea el manejo/manipulación de metadatos). o API flexible para modificar el comportamiento del proxy. o Carga de scripts individuales e independientes para cada página.2.4 DESCRIPCIÓN DE LA REALIZACIÓN2.4.1 Método de desarrollo: El método de desarrollo utilizado para este proyecto será el famoso método dedesarrollo por fases. El método de desarrollo por fases es muy efectivo cuando lacomplejidad de un proyecto es alta. De esta forma el seguimiento, la corrección y laorganización es más fácil y requiere menos tiempo. Para ello se han definido lassiguientes fases:  Análisis: En esta fase se expondrá el problema principal, se analizará y se buscará una solución. Para ello se limitará a los aspectos principales para el planteamiento del problema dejando a un lado aquellos que resulten irrelevantes y/o poco importantes. Asimismo, también se identificarán y establecerán las entradas del problema, así como las salidas o resultados deseados.  Diseño: En esta fase se diseñará una solución adecuada para solventar el problema, por lo que constituye la parte más difícil del proceso de resolución6
  18. 18. PROYECTO FIN DE CARRERA del problema. Es importante tener en cuenta la flexibilidad que se desea conseguir, ya que la flexibilidad de la herramienta viene dada por un diseño flexible.  Implementación: Esta etapa consiste en implementar o escribir el algoritmo como un programa de computadora en un lenguaje de programación, convirtiendo cada paso del algoritmo en instrucciones en el lenguaje de programación. Se requiere el conocimiento de un lenguaje de programación particular en lo referente a su gramática, sintaxis y semántica. Asimismo, se utilizarán los tipos y estructuras de datos más adecuados y se intentará optimizar lo máximo posible el rendimiento.  Verificación y pruebas: Esta fase consiste en probar la herramienta completa así como verificar las pruebas realizadas para comprobar que realiza la función/tarea que se esperaba. Para ello se necesitan datos y situaciones de prueba, que en nuestro caso son páginas web para usar con el proxy, sobre los cuales ejecutar los scripts verificando el correcto funcionamiento de estos últimos.  Documentación: Esta última etapa consiste en la redacción de una documentación del proyecto en la que incluirán explicaciones e indicaciones de todo lo referente al proyecto desarrollado: manuales, organización del proyecto, fases seguidas en la realización del proyecto, tecnologías usadas, glosario, enlaces, etc.2.4.2 Tareas principales: A continuación se van a mostrar tareas principales. A su vez, cada tarea tienevarias subtareas lo que hace que la tabla de tareas esté dividida correctamente yfacilite su lectura. Es importante recalcar que no todos los días se acumulaban 3 horasde trabajo. En ocasiones se han llegado hasta las 10 horas de trabajo y muy pocasveces la carga de trabajo diaria era inferior a las 3 horas. 7
  19. 19. 2. DEFINICIÓN DEL PROYECTO Ilustración 2-1: Tabla de tareasPor otra parte, el diagrama de Gantt asociado a las tareas es el siguiente:8
  20. 20. PROYECTO FIN DE CARRERAIlustración 2-2: Diagrama de Gantt 9
  21. 21. 2. DEFINICIÓN DEL PROYECTO2.5 ORGANIZACIÓN Y EQUIPO La organización del proyecto está formada por un comité de dirección, uno deseguimiento y 2 grupos de trabajo como podemos ver en el siguiente esquema: Ilustración 2-3: Esquema organizativo  Comité de dirección: Este comité tiene como misión ser el órgano que tome las decisiones en el proyecto, y por tanto, sobre el cual recaerá la responsabilidad de dicho proyecto. En en este caso en particular este organismo lo comforma el Dr. Diego López de Ipiña.  Comité de seguimiento: Órgano ejecutivo del proyecto. Al igual que el comité de dirección, éste también tomará decisiones y hará de representante de diferentes departamentos. En en este caso en particular este organismo lo comforma el Dr. Diego López de Ipiña.  Grupo de trabajo: Este grupo será el encargado del desarrollo del proyecto en sí. Su labor consistirá en el desarrollo, instalación e implantación del sistema.10
  22. 22. PROYECTO FIN DE CARRERA Se organizarán reuniones esporádicas (mensuales) para la toma de decisiones, así como para comentar y llegar a soluciones para los diferentes problemas que vayan surgiendo a raíz de la realización del proyecto. En este caso en particular, seremos Iraide Diaz y Xabier Larrakoetxea los que formemos este grupo. Dentro del equipo de trabajo hay varios puestos diferentes y como se hacomentado previamente todos estos puestos se han llevado a cabo por las mismaspersonas. Es decir, las personas que han participado en este proyecto han tenidovarios puestos de trabajo diferentes dentro de la estructura organizativa a lo largo detodo el proyecto. A continuación, se pueden observar los diferentes puestos existentesdentro del equipo de trabajo. Equipo de trabajo o Jefe de proyecto: La tarea de este miembro es la de organizar y dirigir el equipo encargado del proyecto, así como el de asegurarse el cumplimento de los plazos. o Ingenieros informáticos: Desarrollarán la aplicación en su totalidad. Además de ello, se encargarán también de hacer la configuración e implantación del sistema. o Técnicos: Podrían ser los mismos informáticos quienes realizaran el mantenimiento del sistema, pero el hecho de tener un equipo técnico que de apoyo a los ingenieros informáticos es importante. Su tarea será la de mantener el servidor en perfecto funcionamiento en todo momento. o Personal externo: Pese a que no es un equipo de trabajo en sí, es importante recalcar que siempre existirá un personal externo al proyecto. Este personal, brindará ayuda y soporte en diferentes campos relacionados con el proyecto, ya sea en una tecnología software como puede ser un IDE de desarrollo o un lenguaje de programación, o tecnología hardware como puede ser un PC en el puesto de servidor. 11
  23. 23. 2. DEFINICIÓN DEL PROYECTO2.6 PRESUPUESTO Las horas han sido variables durante el transcurso del proyecto, peroaproximadamente las cantidades son las siguientes:  Días laborables: 20días/mes  Horas laborables: 5h/día Perfil Carga Precio Importe Jefe de proyecto 4 días 1.000€/mes 200€ Administrador/Técnico 15 días 800€/mes 600€ Programador 1 130 días 500€/mes 3.250€ Programador 2 130 días 500€/mes 3.250€ Total: 7.300,00€2.7 CONDICIONES DE EJECUCIÓN  Entorno de trabajo Los lugares de trabajo donde se desarrollará el proyecto serán principalmente las instalaciones de la facultad ESIDE de la Universidad de Deusto: las diferentes aulas informáticas, los laboratorios de DeustoTech... Sin embargo, debido a problemas de espacio o a otros motivos algunos de los trabajos también podrán ser realizados desde las casas particulares de los desarrolladores. El calendario estará sujeto al hecho de que los desarrolladores son alumnos de la facultad de Ingeniería de Deusto, con lo cual el horario será bastante flexible dependiendo de las necesidades y los compromisos (horas de clase, reuniones…) de los propios desarrolladores. Por tanto, no estarán sujetos a un horario en particular siempre y cuando se cumplan las horas acordadas previamente (15 horas semanales).  Hardware o 2 Ordenadores portátiles propiedad de los propios desarrolladores. o 2 Ordenadores de sobremesa propiedad de los propios desarrolladores.12
  24. 24. PROYECTO FIN DE CARRERA Software o Sistema Operativo GNU/Linux (distribuciones Arch Linux y Slackware). o Entorno de desarrollo: Geany. o Navegadores: Mozilla Firefox y/o Google Chrome. o Control de versiones: Git. Control de cambios: En el caso de existir alguna petición de modificación o ampliación en los requisitos durante la realización el proyecto, ésta deberá estar sujeta a una serie de directrices que deberán ser cumplidas: 1. Comunicación del/los cambio/s al jefe de proyecto. 2. Presentación de él/ellos al jefe de proyecto. 3. Análisis de los cambios por parte del jefe de proyecto y del comité de seguimiento. 4. Emisión del veredicto y en caso de ser aprobado, modificación tanto de la planificación como del proyecto en sí. Las reuniones con los trabajadores podrán ser diarias o semanales, mientras que las reuniones con el director de proyecto serán cada 3 semanas o mensuales. Recepción de productos: Tras terminar el desarrollo del proyecto y las pruebas del mismo, el servidor será testeado por el jefe de proyecto y dará su aprobación. Una vez aprobado, pasará por una serie de pruebas posteriores las cuales durarán 2 semanas. Tras este periodo de tiempo, se considerará que la herramienta es estable y se procederá a su instalación. Tras las pruebas, se procederá a crear una documentación detallada sobre el proyecto (la cual posteriormente será guardada por el jefe de proyecto) que incluirá como anexo un Manual de Usuario que explicará cómo utilizar y configurar el servidor para enriquecer semánticamente páginas y manejar los metadatos, así como para modificar el comportamiento por defecto del servidor proxy posibilitando así la realización de otros trabajos/tareas por parte de éste. 13
  25. 25. PROYECTO FIN DE CARRERA 3. CONCEPTOS BÁSICOS3.1 PROXY Un proxy pertenece a una red informática donde modifica el comportamiento yla ruta de dicha red. Un proxy lo que hace es representar a otro objeto dentro de dichared. Dicho de otra forma: Un proxy, en una red informática, es un programa odispositivo que realiza una acción en representación de otro, esto es, si una hipotéticamáquina a solicita un recurso a una máquina c, lo hará mediante una petición a lamáquina b; c entonces no sabrá que la petición procedió originalmente de a. Sufinalidad más habitual es la de servidor proxy, que sirve para interceptar lasconexiones de red que un cliente hace a un servidor de destino, por varios motivosposibles como seguridad, rendimiento o anonimato.3.1.1 Tipos  Forward proxies: Ilustración 3-1: Ilustración de un forward proxy Los forward proxies son proxies donde el cliente hace una llamada al servidor externo al que quiere conectarse. Los forward proxies son capaces de recuperar de una amplia gama de páginas. Los términos forward proxy y forwarding proxy son una descripción general de la conducta (reenvío de tráfico) y por lo tanto ambigua. A excepción del proxy inverso (reverse proxy), cuando hablamos de proxies se suele hacer referencia al forward proxy.  Open proxies: 15
  26. 26. 3. CONCEPTOS BÁSICOS Un proxy abierto u open proxy es un servidor proxy de reenvío que es accesible por cualquier usuario de Internet. Este tipo de proxy permite a los usuarios anónimos ocultar su dirección IP mientras navegan por la Web o usar otros servicios de Internet. Ilustración 3-2: Ilustración de un proxy abierto  Reverse proxies: Un proxy inverso es un servidor proxy que se a simple vista de los clientes parece un servidor común. Las solicitudes se envían a uno o más servidores de origen que atenderán la solicitud y la respuesta se devuelve como si viniera directamente del servidor proxy, pero en realidad no es así. Ilustración 3-3: Ilustración de un proxy inverso Los reverse proxies están instalados en conjunto de uno o más servidores Web. Todo el tráfico procedente de Internet y con un destino de uno de los servidores web pasa a través del servidor proxy. El uso del “reverse” se origina en el proxy, ya que el proxy inverso se encuentra más cerca del servidor web y sirve sólo un conjunto limitado de sitios web, al contrario que otros tipos de proxy. Existen varios tipos de reverse proxy: o Cifrado / Aceleración SSL o Load balancing (repartir la carga) o Servir/cachear contenido estático16
  27. 27. PROYECTO FIN DE CARRERA o Compresión o Spoon feeding o Seguridad o Extranet Publishing3.1.2 Funcionamiento Un proxy permite a otros equipos conectarse a una red de forma indirecta através de él. Cuando un equipo de la red desea acceder a una información o recurso através de éste, es realmente el proxy quien realiza la comunicación y a continuacióntraslada el resultado al equipo inicial. En algunos casos, esto se hace de este modo yaque no es posible la comunicación directa, mientras que en otros suele deberse a queel proxy añade una funcionalidad adicional como puede ser la de almacenar losúltimos resultados obtenidos (p.ej.: una página web) en una caché que permitaacelerar sucesivas consultas coincidentes. Con esta denominación general de proxyse agrupan diversas técnicas.3.2 WEB SEMÁNTICA3.2.1 Definición La Web Semántica es una Web extendida, dotada de mayor significado en laque cualquier usuario en Internet podrá encontrar respuestas a sus preguntas deforma más rápida y sencilla gracias a una información mejor definida. Al dotar a laWeb de más significado y, por lo tanto, de más semántica, se pueden obtenersoluciones a problemas habituales en la búsqueda de información gracias a lautilización de una infraestructura común, mediante la cual, es posible compartir,procesar y transferir información de forma sencilla. Esta Web extendida y basada en elsignificado, se apoya en lenguajes universales que resuelven los problemasocasionados por una Web carente de semántica en la que, en ocasiones, el acceso ala información se convierte en una tarea difícil y frustrante. Para ello, se apoya enciertas herramientas y técnicas como pueden ser las ontologías.3.2.2 Utilidades La Web Semántica ha cambiado la forma en la que navegamos. A simple vistala Web Semántica no parece estar ahí, pero su presencia es muy importante. En lacomunicación que vemos en Internet normalmente la Web Semántica está de pormedio ya que las páginas están interconectadas y tienen datos “extra” (metadatos) que 17
  28. 28. 3. CONCEPTOS BÁSICOSnosotros no reconocemos o percibimos, pero que ciertas herramientas software (talescomo los buscadores) que los necesitan, lo usan para llevar a cabo sus tareas. La Web ha cambiado significativamente la forma en la que nos comunicamos,hacemos negocios e incluso trabajamos. Gracias a ella tenemos acceso a millones derecursos en cualquier momento, independientemente de nuestra situación geográfica eidioma. Si bien es cierto que estos factores han contribuido al éxito de la Web. Sinembargo, al mismo tiempo, estos factores que han propiciado el éxito de la Web,también han originado sus principales problemas: sobrecarga de información yheterogeneidad de fuentes de información con el consiguiente problema deinteroperabilidad. La Web Semántica trata de resolver estos los problemas descritos permitiendoa los usuarios delegar tareas en software. Gracias a la semántica en la Web, ahora lasherramientas software pueden procesar su contenido, razonar y realizar deduccioneslógicas de tal forma que las resoluciones a problemas cotidianos se automatizan y seconsiguen resultados más exactos. Existen ciertos escenarios en los que la Web Semántica puede ayudar asolucionar problemas o ayudar con la realización de ciertas tareas. Como ejemplostenemos:  Búsquedas en internet (por ejemplo, para llevar a cabo búsquedas más precisas y exhaustivas con un buscador como Google).  Obtención de datos desde una aplicación móvil (por ejemplo, capturar posición de mapas en una aplicación para Android).  Interconexión de Webs (por ejemplo, para conectar páginas personales de los profesores de una universidad).3.2.3 Funcionamiento18
  29. 29. PROYECTO FIN DE CARRERA Ilustración 3-4: Estructura de la web semántica Para obtener una adecuada definición de los datos, la Web Semántica haceuso de varias tecnologías y mecanismos:  RDF: El Marco de Descripción de Recursos (del inglés Resource Description Framework, RDF) es un framework para metadatos en la World Wide Web (WWW), desarrollado por el World Wide Web Consortium (W3C). Proporciona información descriptiva sobre los recursos que se encuentran en la Web y que se utiliza, por ejemplo, en catálogos de libros, directorios, música, proyectos, documentos, etc.  OWL (Ontologías): OWL es el acrónimo del inglés Ontology Web Language, un lenguaje de marcado para publicar y compartir datos usando ontologías en la WWW. OWL tiene como objetivo facilitar un modelo de marcado construido sobre RDF y codificado en XML. Como definición simple se podría decir que lo que hace OWL es proporcionar un lenguaje para definir ontologías estructuradas que pueden ser utilizadas a través de diferentes sistemas.  SPARQL: SPARQL es un acrónimo recursivo del inglés SPARQL Protocol and RDF Query Language. Se trata de un lenguaje estandarizado para la consulta de grafos RDF que permite hacer búsquedas sobre los recursos de la Web Semántica utilizando distintas fuentes de datos. 19
  30. 30. 3. CONCEPTOS BÁSICOS3.3 ONTOLOGÍAS Dentro de la informática cuando nos referimos a ontologías, se hace referenciaa la formulación de un exhaustivo y riguroso esquema conceptual dentro de undominio dado, para conseguir un intercambio de información más coherente y fácilentre diferentes sistemas. Un uso común tecnológico actual del concepto de ontología, en este sentidosemántico, lo encontramos en la inteligencia artificial y la representación delconocimiento. En algunas aplicaciones, se combinan varios esquemas en unaestructura de facto completa de datos, que contiene todas las entidades relevantes ysus relaciones dentro del dominio. Ilustración 3-5: Ejemplo de ontología Los programas informáticos pueden utilizar así este punto de vista de laontología para una variedad de propósitos, incluyendo el razonamiento inductivo, laclasificación, y una variedad de técnicas de resolución de problemas. Para definir estas ontologías existen actualmente lenguajes o más bienestándares (W3C) que lo posibilitan como es el caso de OWL.20
  31. 31. PROYECTO FIN DE CARRERA3.4 SPARQL SPARQL (SPARQL Protocol and RDF Query Language) es un lenguajeestandarizado para la consulta de grafos RDF que permite hacer búsquedas sobre losrecursos de la Web Semántica utilizando distintas fuentes de datos. BásicamenteSPARQL sería de la misma forma que SQL es para los datos comunes, pero orientadoa la web semántica. Esto significa que SPARQL es la forma que existe para hacerconsultas en una base de datos donde previamente han sido almacenados metadatos. Al igual que sucede con SQL, es necesario distinguir entre el lenguaje deconsulta y el motor para el almacenamiento y recuperación de los datos. Por estemotivo, existen múltiples implementaciones de SPARQL, generalmente ligados aentornos de desarrollo y plataformas tecnológicas. En un principio SPARQL únicamente incorpora funciones para la recuperaciónde sentencias RDF. Sin embargo, algunas propuestas también incluyen operacionespara el mantenimiento (creación, modificación y borrado) de datos.3.5 LINKED DATA Los Datos Enlazados es la forma que tiene la Web Semántica de vincular losdistintos datos que están distribuidos en la Web, de forma que se referencian de lamisma forma que lo hacen los enlaces de las páginas web. De la misma forma que la web de la web del hipertexto, la web de los datos seconstruye mediante documentos en la web. Sin embargo, y a diferencia de la web delhipertexto, donde los enlaces son relaciones entre puntos de los documentos escritosen HTML, los datos enlazan cosas arbitrarias que se describen en RDF. Los datos publicados en la Web se pueden vincular a otros, de forma que laspersonas y las máquinas puedan explorar la web de los datos, pudiendo llegar ainformación relacionada que se hace referencia desde otros datos iniciales. Por tanto,Linked Data permite construir la Web de los datos, es decir, una gran base de datosinterconectados y distribuidos en la Web, lo cual los vuelve más útiles. Los Datos Enlazados, como parte de la Web Semántica, se basa en laaplicación de ciertos principios básicos y necesarios, que fomentarán el crecimiento dela Web, tanto a nivel de los documentos HTML (vista clásica de la Web), como a nivelde los datos expresados en RDF (vista de la Web Semántica). Sir Tim Berners-Leedefinió cuatro principios que caracterizan los datos vinculados en su ponencia depresentación para el W3C. 21
  32. 32. 3. CONCEPTOS BÁSICOS 1. Utilizar URIs para identificar los recursos publicados en la Web. 2. Aprovechar el HTTP de la URI para que la gente pueda localizar y consultar (es decir, desreferenciar) estos recursos. 3. Proporcionar información útil acerca del recurso cuando la URI haya sido desreferenciada. 4. Incluir enlaces a otras URI relacionadas con los datos contenidos en el recurso, de forma que se potencie el descubrimiento de información en la Web. Ilustración 3-6: Conjunto de datos interconectados entre sí que componen la "Nube de Linked Data" Para conseguir tener los datos interconectados y consecuentemente poderpermitir reutilizar la información de cualquier manera esperada o inesperada(ofreciendo un valor añadido a la Web), se deben respetar los cuatro pasos anteriores.3.6 EXPRESIONES REGULARES Una expresión regular, a menudo llamada también patrón, es una expresiónque describe un conjunto de cadenas sin enumerar sus elementos. Por ejemplo, elgrupo formado por las cadenas Handel, Händel y Haendel se describe mediante elpatrón "H(a|ä|ae)ndel". La mayoría de las formalizaciones proporcionan los siguientesconstructores: una expresión regular es una forma de representar a los lenguajesregulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el22
  33. 33. PROYECTO FIN DE CARRERAcual se define el lenguaje. Específicamente, las expresiones regulares se construyenutilizando los operadores unión, concatenación y clausura de Kleene. Además cadaexpresión regular tiene un autómata finito asociado. En el área de la programación, las expresiones regulares son un método pormedio del cual se pueden realizar búsquedas dentro de cadenas de caracteres. Sinimportar si la búsqueda requerida es de dos caracteres en una cadena de 10 o si esnecesario encontrar todas las apariciones de un patrón definido de caracteres en unarchivo de millones de caracteres, las expresiones regulares proporcionan unasolución para el problema. Adicionalmente, un uso derivado de la búsqueda depatrones es la validación de un formato específico en una cadena de caracteres dada,como por ejemplo fechas o identificadores. Para poder utilizar las expresiones regulares al programar es necesario teneracceso a un motor de búsqueda con la capacidad de utilizarlas. Es posible clasificarlos motores disponibles en dos tipos:Motores para el usuario final Son programas que permiten realizar búsquedas sobre el contenido de unarchivo o sobre un texto extraído y colocado en el programa. Están diseñados parapermitir al usuario realizar búsquedas avanzadas usando este mecanismo. Sinembargo es necesario aprender a redactar expresiones regulares adecuadas parapoder utilizarlos eficientemente. Éstos son algunos de los programas disponibles:  grep: programa de los sistemas operativos Unix/Linux.  PowerGrep: versión de grep para los sistemas operativos Windows.  RegexBuddy: ayuda a crear las expresiones regulares en forma interactiva y luego le permite al usuario usarlas y guardarlas.  EditPad Pro: permite realizar búsquedas con expresiones regulares sobre archivos y las muestra por medio de código de colores para facilitar su lectura y comprensión.Motores para el programador Permiten automatizar el proceso de búsqueda de modo que sea posibleutilizarlo muchas veces para un propósito específico. Estas son algunas de lasherramientas de programación disponibles que ofrecen motores de búsqueda consoporte a expresiones regulares:  Java: existen varias bibliotecas hechas para java que permiten el uso de RegEx, y Sun planea dar soporte a estas desde el SDK  JavaScript: a partir de la versión 1.2 (ie4+, ns4+) JavaScript tiene soporte integrado para expresiones regulares.  Perl: es el lenguaje que hizo crecer a las expresiones regulares en el ámbito de la programación hasta llegar a lo que son hoy en día. 23
  34. 34. 3. CONCEPTOS BÁSICOS  PCRE: biblioteca de ExReg para C, C++ y otros lenguajes que puedan utilizar bibliotecas dll (Visual Basic 6 por ejemplo).  PHP: tiene dos tipos diferentes de expresiones regulares disponibles para el programador, aunque la variante POSIX (ereg) va a ser desechada en PHP 6.  Python: lenguaje de "scripting" popular con soporte a Expresiones Regulares.  .Net Framework: provee un conjunto de clases mediante las cuales es posible utilizar expresiones regulares para hacer búsquedas, reemplazar cadenas y validar patrones. En Python las expresiones regulares tienen una sintaxis la cual podemosapreciar en la siguiente tabla. Cabe mencionar que no se trata de la tabla completa, yaque es muy amplia, pero se puede ver lo más importante: Patrón Descripción ^ Principio de linea $ Final de linea Cualquier character salvo cambio de linea (con la opción m adopta . también cambio de linea) [...] Cualquier character dentro de los corchetes [^...] Cualquier character diferente dentrod e los corchetes re* 0 o más ocurrencias re+ 1 o más ocurrencias re? 0 o 1 ocurrencias re{ n} Exactamente “n” ocurrencias re{ n,} N o más ocurrencias24
  35. 35. PROYECTO FIN DE CARRERAre{ n, m} De n a m ocurrencias a| b Aob (re) Agrupa expresiones regulares Temporalmente activa las opciones I, m, o x en una expresión (?imx) regular dentro del parentesis Temporalmente desactiva las opciones I, m, o x en una expresión (?-imx) regular dentro del parentesis (?: re) Agrupa expresiones regulares sin memorizar la ocurrencia del texto Temporalmente desactiva las opciones I, m, o x en una expresión(?imx: re) regular Temporalmente desactiva las opciones I, m, o x en una expresión(?-imx: re) regular (?#...) Comentarío (?= re) Posición especifica dentro del patron. No tiene rango (?! re) Posición especifica dentro del patrón negado. No tiene rango. (?> re) Asocia un patron independiente sin usar “Backtracking” w Asocia caracteres de palabras W Asocia caracteres de “no palabras” s Asocia espacios en blanco. Equivalente a [tnrf]. 25
  36. 36. 3. CONCEPTOS BÁSICOS S Asocia no espacios en blanco d Asocia dígitos. Equivalente a [0-9]. D Asocia “no dígitos” A Asocia principio de un string (cadena de caracteres) Asocia final de un string.Si existe una nueva linea, lo asocial justo Z hasta el comienzo de z Asocia final de un string G Asocia la posición en la qu ese encotrntro la última asociación Un ejemplo de uso de expresiones regulares en Python sería este pequeñosnippet de código. Lo que hace es buscar el patron “<body>” indicándole que despuésde “<body>” y antes de “>” puede haber: espacios, =, “ o caracteres. import re regularExpressionIn = <body[w"= ]*> reg = re.compile(regularExpressionIn) m = reg.search(body) Código 3-1: Ejemplo de expresión regular en Python3.7 GRDDL GRDDL son las siglas de Gleaning Resource Descriptions from Dialects ofLanguages o en castellano: "Espigar Descripciones de Recursos de Dialectos deLenguajes". Una explicación sencilla para GRDDL sería tan simple como “un extractorde metadatos”. Sin embargo, no es tan simple como parece.26
  37. 37. PROYECTO FIN DE CARRERA GRDDL es una forma de indicar una transformación, comúnmente medianteXSLT, de un documento XHTML o XML para obtener información en RDF. Medianteesta indicación, una aplicación informática puede extraer de forma automáticainformación de páginas web estructuradas para integrarla en la Web Semántica.3.7.1 Ejemplo con XHTML Un documento especifica transformaciones asociadas usando varias formas.Por ejemplo un document XHTML puede contener lo siguiente: <head profile="http://www.w3.org/2003/g/data-view http://dublincore.org/documents/dcq-html/ http://gmpg.org/xfn/11"> <link rel="transformation" href="grokXFN.xsl" /> Código 3-2: Declaración de transformación GRDDL en XHTML En el argumento “profile” se da a conocer que este documento tienetransformación mediante GRDDL, en concreto en “http://www.w3.org/2003/g/data-view”.La transformación se hará mediante el atributo “transformation” que apuntará a la hojaXSL (en este caso grokXFN.xsl ) que marcará la forma en la que se extraerá lainformación. Cabe destacar que este código es valido para XHTML 1.x, ya que en HTML elatributo “profile” ha sido eliminado.3.7.2 Microformatos Por otra parte, una página puede contener microformatos. Para ello, senecesita un perfil (profile) específico que marcará la forma en la que se extraen datosdel documento. Por ejemplo, un documento que tiene hcard mediante microformatos deberíade tener lo siguiente en su cabecera: <head profile="http://www.w3.org/2003/g/data-view http://www.w3.org/2006/03/hcard"> Código 3-3: Declaración de transformación GRDDL para hcard con MicroformatosDentro de ese link a hcard tenemos: <head profile="http://www.w3.org/2003/g/data-view"> 27
  38. 38. 3. CONCEPTOS BÁSICOS Código 3-4: Profile de GRDDL dentro de hcardY por último: <p>Use of this profile licenses RDF data extracted by <a rel="profileTransformation" href="../vcard/hcard2rdf.xsl">hcard2rdf.xsl</a> from <a href="http://www.w3.org/2006/vcard/ns">the 2006 vCard/RDF work</a>. </p>Código 3-5: Datos de hcard conteninedo el XSL para transformar microformatos hcard en GRDDL28
  39. 39. PROYECTO FIN DE CARRERA 4. JUSTIFICACIÓN La realización de este proyecto está ligada a la necesidad de que cada vezmás páginas están convirtiéndose a páginas web semantizadas (es decir, páginas conmetadatos). A día de hoy, un gran porcentaje de páginas web tiene metadatos que asimple vista el humano no puede ver sin usar herramientas externas, por ello unasolución sería la fácil extracción de metadatos.4.1 BENEFICIOS TÉCNICOS Los beneficios técnicos son bastante altos. En primer lugar debemos tener encuenta que necesitamos una extracción o introducción de metadatos. Eso aportaría unvalor en tiempo y esfuerzo. Por ejemplo, una empresa requiere un análisis de los RDFque actualmente su página trata. Con el esta herramienta la visualización de esosmetadatos sería rápida y sin tener que hacer un despliegue grande de herramientas yrecursos. Por otra parte, si una vez analizados los metadatos se quisiera realizar unainserción de metadatos rápida, ésta se podría hacer mediante el propio servidor proxytras modificar su funcionamiento mediante un script. Esto permitiría ver los nuevosmetadatos en la página, pero sin embargo, no serían cambios definitivos. De estaforma, podríamos pasar a hacerlos permanentes, haciendo las modificacionespertinentes en la página original y el servidor. Así la inserción de metadatos medianteel servidor proxy se podría hacer como prueba antes de hacerlo definitivo. Asimismo, como un efecto no orientado a la web semántica y ligado al cambiode funcionamiento del servidor proxy mediante scripts, también se podría usar el proxypara cambiar el aspecto e incluso el comportamiento de una página.4.2 BENEFICIOS ECONÓMICOS Los beneficios económicos no son tan claros como los técnicos. La herramientaen sí, aportaría beneficio del tipo de ahorro en tiempo, herramientas y personal, quetraducido en términos económicos sería un ahorro alto al no tener que hacer uso deesos recursos. A esto se le puede sumar que el aprendizaje de uso de la herramientaes sencillo e intuitivo y no requiere mucha preparación para su manejo, por tanto, losgastos derivados de la formación en el uso de la herramienta tampoco serían muyaltos. 29
  40. 40. PROYECTO FIN DE CARRERA 5. INVESTIGACIÓN EN TECNOLOGÍAS5.1 VISIÓN GENERAL En este capítulo se van a explicar las diferentes tecnologías utilizadas en eldesarrollo del Proyecto, las cuales se expondrán de forma teórica y explicativa asícomo algún ejemplo práctico de ellas.5.2 RECURSOS PRINCIPALES5.2.1 Python Ilustración 5-1: Logo de Python Python es un lenguaje de programación, interpretado, rápido y flexible. Cadaaño gana nuevos adeptos y es de los lenguajes más utilizados actualmente. Es unlenguaje de alto nivel cuya filosofía hace hincapié en una sintaxis muy limpia y quefavorezca un código legible. Se trata de un lenguaje de programación multiparadigma ya que soportaorientación a objetos, programación imperativa y, en menor medida, programaciónfuncional. Es un lenguaje interpretado, usa tipado dinámico, es fuertemente tipado ymultiplataforma. Es administrado por la Python Software Foundation. Posee una licencia decódigo abierto, denominada Python Software Foundation License, que es compatiblecon la Licencia pública general de GNU a partir de la versión 2.1.1, e incompatible enciertas versiones anteriores. 31
  41. 41. 5. INVESTIGACIÓN EN TECNOLOGÍAS5.2.1.1 Tipos de datos Los tipos de datos que existen en este lenguaje, estos se pueden resumir en lasiguiente tabla: Tipo Clase Notas Ejemplo str Cadena Inmutable Cadena unicode Cadena Versión Unicode de str uCadena Mutable, puede contener objetos list Secuencia [4.0, Cadena, True] de diversos tipos Inmutable, puede contener tuple Secuencia (4.0, Cadena, True) objetos de diversos tipos Mutable, sin orden, no contiene set([4.0, Cadena, set Conjunto duplicados True]) Inmutable, sin orden, no frozenset([4.0, frozenset Conjunto contiene duplicados Cadena, True]) {key1: 1.0, key2: dict Mapping Grupo de pares clave:valor False} Número Precisión fija, convertido en long int 42 entero en caso de overflow. Número 42L ó long Precisión arbitraria entero 456966786151987643L Número float Coma flotante de doble precisión 3.1415927 decimal bool Booleano Valor booleano verdadero o falso True o False32
  42. 42. PROYECTO FIN DE CARRERA5.2.1.2 Ejemplo práctico A modo de ejemplo práctico, en las siguientes líneas se va a mostrar unpequeño programa desarrollado en Python con su correspondiente resultado devueltopor pantalla. En primer lugar, un ejemplo de una función (que en este caso calcula elfactorial) escrita en este lenguaje podría ser el siguiente: def factorial(x): if x == 0: return 1 else: return x * factorial(x - 1) Código 5-1: Ejemplo de una función en Python Asimismo, Python al igual que muchos lenguajes de programación es orientadoa objetos. En el siguiente bloque de código, se declara una clase y luego se llama alobjeto: class Test: def __init__(self, x, y): self._x = x self._y = y def _suma(self): return self._x + self._y def suma(self): return self._suma() Código 5-2: Ejemplo de una clase en Python En el bloque de código que viene a continuación se pueden ver la combinaciónde los dos ejemplos anteriores en un script (o programa) de Python. La funciónfactorial se encuentra en un archivo llamado factorial.py y la clase Test en unarchivo llamado pythonTestClass.py: from pythonTestClass import Test from factorial import factorial t = Test(1,3) x = t.suma() print factorial(x) 33
  43. 43. 5. INVESTIGACIÓN EN TECNOLOGÍAS Código 5-3 Ejemplo de un script (programa) en Python Finalmente, tras la ejecución del anterior bloque de código, en las siguienteslíneas se muestra el resultado obtenido por línea de comandos (Python es un lenguajeinterpretado y por tanto, los programas realizados en este lenguaje se podrían ejecutardirectamente escribiéndolos en la línea de comandos propia de Python, no siendonecesaria la escritura de un script/programa (fichero), pese a que esto último sea lomás común.) slok@sLoKPC:pythonPFCDoc$ python ./test.py 11 24 Código 5-4 Resultado del ejemplo anterior5.2.1.3 Integración con el proyecto En lo que a respecta al uso de Python dentro del proyecto, mencionar que todoel código del proyecto ha sido escrito en este lenguaje. Es más, incluso el propiocódigo HTML del portal para el manejo del servidor proxy ha sido desarrolladomediante Python, usando para ello el Framework de Desarrollo Django. Las razones por las que se ha elegido este lenguaje de programación sepodrían resumir en varios puntos:  Es un lenguaje muy flexible.  El lenguaje es interpretado, por tanto, es fácil de poner en marcha.  Tiene muchas y muy buenas librerías incluidas (como cita un slogan de Python: “¡Con baterías incluidas!”), además de existir una cantidad mayor de librerías escritas por terceros.  Tiene gran cantidad de documentación de excelente calidad, algo que para el aprendizaje y un buen desarrollo es muy importante.  La curva de aprendizaje es corta.  Cada vez se usa más este lenguaje.  Es de los lenguajes que más potencia tiene (o que se le puede sacar).  Su sintaxis es muy clara, ya que requiere que se tabule obligatoriamente.  Soporta objetos, clases abstractas, encapsulación…  Es una tecnología nueva para nosotros. Para el desarrollo del proyecto decidimos utilizar algo nuevo que no supiéramos manejar de antemano (es decir, que no hubiéramos visto a lo largo de la carrera), de modo que constituiría una muy buena ocasión para aumentar nuestro conocimiento (consideramos que el aprender nuevas cosas dentro del oficio de un Ingeniero Informático, es algo importante).  Es multiplataforma  Es software libre34
  44. 44. PROYECTO FIN DE CARRERA5.2.2 Django Ilustración 5-2: Logo Django Después de haber elegido Python como lenguaje de programación para elproyecto, era necesario elegir el framework con el que se iba a desarrollar el portalweb. Para Python existen muchas opciones principales:  Django  Web2Py  Pylons  Turbogears  WebPyDe todas ellas la elegida fue Django, por las siguientes razones:  Flexible, al igual que Python.  Tienen filtros que hacen muchos trabajos de manera automatizada.  Amplia documentación disponible.  Estable.  Muchas webs famosas lo usan.  Rápida puesta en marcha.  Funcionamiento excelente con servidores de producción (Apache, Nginx…).  Administrador de Django excelente (para la administración de usuarios, grupos…).  Muy rápido.  Es multiplataforma (sobre python)  Es software libre. Django es un framework de desarrollo web de código abierto, escrito enPython, que cumple en cierta medida el paradigma del Modelo Vista Controlador(MVC). Fue desarrollado en origen para gestionar varias páginas orientadas a noticiasde la World Company de Lawrence, Kansas, y fue liberada al público bajo una licenciaBSD en julio de 2005. 35
  45. 45. 5. INVESTIGACIÓN EN TECNOLOGÍAS La meta fundamental de Django es facilitar la creación de sitios web complejos.Django pone énfasis en el re-uso, la conectividad y extensibilidad de componentes, eldesarrollo rápido y el principio “No te repitas” (DRY, del inglés Dont Repeat Yourself).Python es usado en todas las partes del framework, incluso en configuraciones,archivos, y en los modelos de datos.5.2.2.1 Características Entre las características/herramientas que dispone Django, aparte de laspreviamente comentadas, existen muchas otras:  Un mapeador objeto-relacional.  Aplicaciones "enchufables" que pueden instalarse en cualquier página gestionada con Django.  Una API de base de datos robusta.  Un sistema incorporado de "vistas genéricas" que ahorra tener que escribir la lógica de ciertas tareas comunes.  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; por ejemplo, la distribución principal de Django incluye componentes middleware que proporcionan cacheo, compresión de la salida, normalización de URLs, protección CSRF y soporte de sesiones.  Soporte de internacionalización, incluyendo traducciones incorporadas de la interfaz de administración.  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). Pese a que Django se trata de un framework de Modelo Vista Controlador, enrealidad se caracteriza por otro nombre ya que difiere un poco de lo que comúnmentese tiene en mente, aunque en el fondo sea lo mismo. Esta característica es una de lasque hace especial a Django sobre otros frameworks. Como cita la Wikipedia: “Aunque Django está fuertemente inspirado en la filosofía de desarrollo ModeloVista Controlador, sus desarrolladores declaran públicamente que no se sientenespecialmente atados a observar estrictamente ningún paradigma particular, y encambio prefieren hacer "lo que les parece correcto". Como resultado, por ejemplo, loque se llamaría "controlador" en un "verdadero" framework MVC se llama en Django"vista", y lo que se llamaría "vista" se llama "plantilla". Gracias al poder de las capas mediator y foundation, Django permite que losdesarrolladores se dediquen a construir los objetos Entity y la lógica de presentación ycontrol para ellos.”36
  46. 46. PROYECTO FIN DE CARRERA Para poder usar Django, tan sólo es necesario tener instalado Python. Conesto, Django podría funcionar perfectamente ya que trae consigo un servidor dedesarrollo (no apto para producción) y Sqlite3. En cuanto a otras BD, Django tambiénsoporta MySQL, PostgreSQL y Oracle.5.2.2.2 Funcionamiento El flujo que sigue Django es algo particular. En la siguiente imagen y surespectiva explicación se ve claramente cómo actúa Django: Ilustración 5-3: Flujo 1. El servidor que sirve la página creada con Django recibe la petición del cliente 2. Esta petición es mapeada con el URL Dispatcher (urls.py) y llama a las funciones que sean necesarias (views.py) que previamente hayan sido asignadas o si se tiene una versión cacheada, esta será la que se devolverá en vez de llamar a la función. 3. Una vez se está ejecutando el código de la función definida en views.py se suelen hacer operaciones de escritura y lectura en bases de datos (aunque en ocasiones no se hace y se ejecutan otras acciones). Para ello los modelos de la base de datos se especifican en models.py. 4. A continuación la vista lo último que hará será pasar el paquete HTTP que será devuelto, para ello lo suele pasar los datos por la template o plantilla. 5. El/los paquete(s) se envía a su destinatario. 37

×