Final Project on DHCP66 and TR069
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA DE
TELECOMUNICACIÓN
UNIVERSIDAD POLITÉCNICA DE CARTAGENA
Trabajo Fin de Grado
Desarrollo de servicios de auto-configuración de
encaminadores cliente tipo Ethernet, ADSL y de voz
usando protocolos basados en DHCP66 y TR069
AUTOR: Sergio Fernández Rubio
DIRECTOR: Francesc Burrull i Mestres
CODIRECTOR: Mathieu Kessler
Septiembre / 2015
Sergio Fernández Rubio
Trabajo Fin de Grado
Índice general
Capítulo 1. Introducción. .......................................................................................... 10
Capítulo 2. Estado de la técnica. ............................................................................... 13
2.1. DHCP Option 66 ....................................................................................................13
2.1.1. Servidores TFTP ..............................................................................................13
2.1.1.a. Xinetd .......................................................................................................13
2.1.1.b. Tftpd32 ....................................................................................................14
2.1.1.c. PumpKIN ..................................................................................................14
2.1.2. Servidores HTTP .............................................................................................15
2.1.2.a. Apache HTTP Server ................................................................................15
2.1.2.b. Ngnix ........................................................................................................16
2.2. Technical Report 069 (TR-069) ..............................................................................17
2.2.1. ACS .................................................................................................................18
2.2.1.a. GenieACS .................................................................................................18
2.2.1.b. Easycwmp ................................................................................................19
2.2.1.c. AXESS.ACS ................................................................................................20
2.2.1.d. Unified Device Management Platform de AVSystem ..............................22
2.3. Lenguajes de programación ..................................................................................23
2.3.1. R......................................................................................................................23
2.3.2. Python ............................................................................................................25
2.3.3. Java .................................................................................................................26
2.4. Markdown .............................................................................................................27
2.5. Bases de Datos ......................................................................................................27
2.5.1. Soluciones SQL ...............................................................................................28
2.5.1.a. MySQL ......................................................................................................28
2.5.1.b. PostgreSQL ...............................................................................................29
2.5.1.c. SQLite .......................................................................................................30
2.5.2. Soluciones NoSQL...........................................................................................32
2.5.2.a. MongoDB .................................................................................................32
2.6. Routers ..................................................................................................................33
2.6.1. Cisco Systems Inc. ...........................................................................................34
2.6.2. MikroTik Ltd. ..................................................................................................34
2.6.3. Juniper Networks ...........................................................................................35
2.7. XML .......................................................................................................................36
2.8. ¿Por qué se ha elegido la opción propuesta? .......................................................37
Capítulo 3. Tecnología utilizada. ............................................................................... 41
3.1. Xinetd ....................................................................................................................41
3.2. Apache HTTP Server ..............................................................................................46
3.3. El entorno de trabajo RStudio, R y el paquete Shiny ............................................46
3.3.1. RStudio ...........................................................................................................46
3.3.2. R......................................................................................................................48
3
Sergio Fernández Rubio
Trabajo Fin de Grado
3.3.3. Shiny ...............................................................................................................54
3.4. DHCP Option 66 ....................................................................................................57
3.5. GenieACS ...............................................................................................................59
3.6. RMarkdown ...........................................................................................................61
Capítulo 4. Router Express. ...................................................................................... 64
4.1. Explicación de uso .................................................................................................64
4.2. Presentación y explicación de código R ................................................................72
4.3. Servicio de DHCP Option 66 ................................................................................107
4.3.1. Configuración de los servidores TFTP y HTTP ..............................................107
4.3.2. Configuración del servidor Samba ...............................................................108
4.3.3. Activación de DHCP66 en cada MikroTik .....................................................109
4.3.4. Script para cambio de DNS masivo en cada MikroTik ................................. 110
Capítulo 5. Conclusiones y trabajos futuros. ........................................................... 114
Bibliografía. ........................................................................................................... 117
ANEXO A: Instalación RStudio y gestión de paquetes. ............................................ 119
4
5
Índice de figuras
Figura 1: Tftpd32 logo y vista principal de la GUI ........................................................... 14
Figura 2: GUI de PumpKIN para OSX .............................................................................. 14
Figura 3: Comparativa de la cuota de mercado de los servidores web ......................... 15
Figura 4: Apache vs Nginx ............................................................................................... 15
Figura 5: Logo de Apache HTTP Server ........................................................................... 16
Figura 6: Logo de Nginx .................................................................................................. 16
Figura 7: Ejemplo de despligue de TR-069 ..................................................................... 17
Figura 8: Ejemplo de transacción entre CPE y ACS ......................................................... 17
Figura 9: Logo de GenieACS ............................................................................................ 18
Figura 10: Gráficos de monitorización en la pantalla principal de GenieACS ................ 19
Figura 11: Logo de EasyCwmp ........................................................................................ 19
Figura 12: Esquema de funcionamiento de EasyCwmp ................................................. 20
Figura 13: Logo de AXESS.ACS ........................................................................................ 20
Figura 14: Pantalla principal de AXESS.ACS .................................................................... 21
Figura 15: Logo de AVSystem ......................................................................................... 22
Figura 16: Vistazo de la aplicación en su modo de localización de dispositivos ............ 23
Figura 17: Logo de R ....................................................................................................... 24
Figura 18: Pantalla principal de RGui para Windows ..................................................... 24
Figura 19: Logo de Python .............................................................................................. 25
Figura 20: Ejemplo de código en Python ........................................................................ 26
Figura 21: Logo de Java................................................................................................... 26
Figura 22: Entorno Eclipse de desarrollo Java ................................................................ 27
Figura 23: SQL ................................................................................................................. 28
Figura 24: Logo de MySQL .............................................................................................. 28
Figura 25: Logo de PostgreSQL ....................................................................................... 29
Figura 26: Líneas de código frente a versión de SQL ...................................................... 30
Figura 27: Logo de SQLite ............................................................................................... 30
Figura 28: Familia de bases de datos NoSQL .................................................................. 32
Figura 29: Logo de MongoDB ......................................................................................... 33
Figura 30: Interesante comparativa entre una consulta en MySQL frente a la misma en
MongoDB ........................................................................................................................ 33
Figura 31: Modelo tradicional de un router ................................................................... 34
Figura 32: Logo de Cisco ................................................................................................. 34
Figura 33: Logo de MikroTik ........................................................................................... 35
Figura 34: Logo de Juniper Networks ............................................................................. 35
Figura 35: Logo de XML .................................................................................................. 36
Figura 36: Seguridad, ante todo, en xinetd .................................................................... 41
Figura 37: Creación de archivo de test ........................................................................... 45
Figura 38: Petición de archivo de test vía tftp ................................................................ 45
Figura 39: Comprobación de archivo recibido ............................................................... 45
Figura 40: Entorno de trabajo RStudio ........................................................................... 47
Figura 41: Configuraciones Globales de RStudio ............................................................ 47
6
Figura 42: Logo de la conferencia internacional anual sobre R ..................................... 49
Figura 43: Ilustración artística de Shiny.......................................................................... 54
Figura 44: Ejemplo de app en Shiny ............................................................................... 55
Figura 45: Esquema de red para DHCP66 ....................................................................... 57
Figura 46: Ejemplo de consulta DHCP66 ........................................................................ 58
Figura 47: Configuración de DHCP Server MikroTik, incluyendo DHCP66 ..................... 58
Figura 48: Ejemplo de creación de preset mediante GUI............................................... 59
Figura 49: Ejemplo de documento RMarkdown y su output en HTML .......................... 61
Figura 50: Vista principal de la WebApp basada en el paquete Shiny ........................... 63
Figura 51: Router Express con todas las opciones de configuración de router y ticket
activadas ......................................................................................................................... 65
Figura 52: Eligiendo del número de conexión ................................................................ 65
Figura 53: Opciones que aparecen al escoger una conexión diferente la primera ....... 66
Figura 54: Elección de servicio contratado ..................................................................... 66
Figura 55: Selección de fecha de expiración .................................................................. 67
Figura 56: Creación de archivo MAC .............................................................................. 67
Figura 57: Opciones de entrada para el nuevo ticket .................................................... 68
Figura 58: Ubicaciones en La Manga .............................................................................. 68
Figura 59: Vista previa del FAQ....................................................................................... 69
Figura 60: Barra de carga ................................................................................................ 69
Figura 61: Resultados visibles de la aplicación ............................................................... 69
Figura 62: Widgets adicionales al escoger el router Grandstream HT502 ..................... 70
Figura 63: Tab para la creación manual de archivos de configuración Tenda W308R .. 71
Figura 64: Tab para la creación manual de archivos de configuración Grandstream
HT502 .............................................................................................................................. 71
Figura 65: Vista vía Winbox de un MikroTik ................................................................. 109
Figura 66: Seleccionando un DHCP Server ................................................................... 109
Figura 67: Creando opción dhcp66............................................................................... 110
Figura 68: Dhcp66 insertado ........................................................................................ 110
Figura 69: Página web de R CRAN ................................................................................ 119
Figura 70: Página de descarga para Windows .............................................................. 119
Figura 71: Finalmente, podemos descargar R .............................................................. 120
Figura 72: Pantalla principal del asistente de instalación para Windows .................... 120
Figura 73: Elección de componentes a instalar ............................................................ 121
Figura 74: Elección de opciones de configuración ....................................................... 121
Figura 75: MDI o SDI ..................................................................................................... 122
Figura 76: Tareas adicionales ....................................................................................... 122
Figura 77: Zona de descarga de RStudio ...................................................................... 123
Figura 78: Descarga de RStudio Desktop en función del sistema operativo instalado 123
Figura 79: Pantalla principal del asistente de instalación de RStudio Desktop ........... 124
Figura 80: Pantalla principal de RStudio ....................................................................... 124
Figura 81: Instalando paquetes .................................................................................... 125
Figura 82: Actualizando paquetes ................................................................................ 125
7
8
9
Sergio Fernández Rubio
Trabajo Fin de Grado
Capítulo 1. Introducción.
En la actualidad, vivimos en una Era de la Información (también conocida como Era
Digital o Era Informática) donde las tecnologías de la información y las comunicaciones
están avanzando a pasos agigantados. Millones de dispositivos electrónicos se
conectan a Internet cada día, y el flujo de información es cada vez mayor, alcanzando a
diario cientos de petabytes [1].
En medio de esta situación, cada día más usuarios necesitan de los servicios de
Internet en todo lugar, haciendo que aumente a grado exponencial el número de
dispositivos de red necesarios para satisfacer al cliente. Esto es conocido generalmente
como el Internet de las cosas (En inglés, Internet of Things). Este es un concepto que se
refiere al hecho de digitalizar y proveer de conexión a Internet a objetos cotidianos.
Más que nunca, en este sentido la revolución está llegando ya para todos los
electrodomésticos de casa. Es por ello que se necesitan protocolos de actuación en
red, para que satisfagan la ingente cantidad de nuevos usuarios y servicios conectados
a Internet.
Primero, en esta memoria explicativa, hablaremos del protocolo DHCP66 y la opción
66 que este protocolo incluye. Veremos cómo se gestiona el provisionamiento del
archivo de configuración para los Tenda W308R y para los Grandstream HT502.
También veremos cómo se crean estos archivos de configuración en el lenguaje
escogido de programación R.
Seguido de esto, hablaremos de la parte del código dedicada a la gestión del alta de
nuevo cliente PPPoE, con el fin de proveer de Internet al cliente. Veremos el flujo de
datos entre las diferentes bases de datos con las que la empresa trabaja, y los escollos
a superar. También estudiaremos la estructura de las diferentes bases de datos.
Por último, explicaremos la incorporación (opcional) de un nuevo ticket de instalación
para la posterior gestión por parte de las encargadas de llevar a cabo las instalaciones
de nuevos clientes. En esta parte usaremos, junto a R, un script hecho en Python con el
paquete Selenium, para así navegar por la web de la base de datos de tickets.
10
Sergio Fernández Rubio
Trabajo Fin de Grado
11
12
Sergio Fernández Rubio
Trabajo Fin de Grado
Capítulo 2. Estado de la técnica.
Empezaremos hablando acerca de los métodos de autoconfiguración de dispositivos.
Estos se basan fundamentalmente en los que hemos usado en este trabajo, y son el de
DHCP Option 66 y el Technical Report 069. Aunque diferentes, ambos tienen en común
que son realmente prácticos a la hora de reducir el tiempo de set-up para un nuevo
router.
2.1. DHCP Option 66
El servicio de aprovisionamiento del DHCP66 sigue un esquema más básico que el de
TR069, siendo éste el que a continuación explicaremos.
El sevicio DHCP66 se nutre del servicio DHCP, con el que se obtiene la dirección IP de
cualquier nuevo cliente que se conecte a la red. En el mismo paquete que envía el
servidor DHCP con la IP del CPE, envía también la opción 66 [2].
Este servidor puede no estar en la misma red local que la del Tenda W308R, y por lo
tanto esta petición la haría mediante un DHCP Relay. Como segunda opción, el mismo
equipo que ejerce como DHCP Relay podría ser el que le suministrara el servicio de
DHCP66
Tras la petición de la opción 66, el servidor DHCP le respondería con una IP. Esta IP es la
IP del servidor TFTP. Es a esa IP a donde debe ir el router a preguntar por su archivo de
configuración. Así que eso hará, y conseguirá autoconfigurarse con ese archivo de
configuración que descarga.
2.1.1. Servidores TFTP
Tenemos varias opciones a considerar en cuanto a la elección de provisión de servicios
TFTP, todas ellas Open Source, tales como xinetd, tftpd32 o PumpKIN.
2.1.1.a. Xinetd
Xinetd es un servicio dedicado a administrar la conectividad basada en Internet [3]. Por
tanto, es mucho más que un servidor TFTP. Es un servicio diseñado para sistemas
UNIX. Sus siglas significan “eXtended InterNET Daemon”. En su versión anterior,
llamada inetd, contenía menos seguridad que la que implementa xinetd.
Para su correcto funcionamiento, necesitaremos los paquetes auxiliares de xinetd:
tftpd y tftp.
13
Sergio Fernández Rubio
Trabajo Fin de Grado
2.1.1.b. Tftpd32
Ejecutable de Windows, que incluye no sólo un servidor TFTP, sino que incluye
servidores DHCP, DNS y SNTP, como también un cliente TFTP [4].
Figura 1: Tftpd32 logo y vista principal de la GUI
2.1.1.c. PumpKIN
Disponible tanto para Windows como para OSX, incluye tanto servidor TFTP como
cliente TFTP [5].
Figura 2: GUI de PumpKIN para OSX
14
Sergio Fernández Rubio
Trabajo Fin de Grado
2.1.2. Servidores HTTP
Los servidores HTTP se definen como servidores que procesan peticiones vía HTTP.
Desde que surgió Internet, los servidores web no han parado de aumentar en tamaño,
número, complejidad y funcionalidad, como vemos en la siguiente comparativa [6]:
Figura 3: Comparativa de la cuota de mercado de los servidores web
En nuestro desarrollo, analizaremos los servidores Apache y Nginx, los grandes OpenSource de hoy en día.
Figura 4: Apache vs Nginx
2.1.2.a. Apache HTTP Server
El proyecto Apache HTTP Server es un esfuerzo conjunto de desarrollar y mantener un
servidor HTTP Open-Source para sistemas operativos modernos, incluyendo Unix y
Windows [7].
15
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 5: Logo de Apache HTTP Server
Nacido en 1995, el objetivo del proyecto es proveer un servidor extensible, eficiente y
seguro, en sincronización con el estándar HTTP.
Es el servidor más usado en todo el mundo. La mayor diferencia entre Apache y Ngnix
es la manera de manejar las conexiones y el tráfico. Apache usa módulos de
multiproceso (MPM), que dictan cómo las peticiones de los clientes son manejadas.
Esto hace que los administradores manejen la arquitectura de gestión de las
conexiones de manera sencilla.
2.1.2.b. Nginx
Con la concurrencia en mente, nginx nació en 2004 por manos de Igor Sysoev, en
respuesta al problema C10K, que era un reto para los servidores web que signficaba
gestionar 10.000 conexiones concurrentes como mínimo [8].
Figura 6: Logo de Nginx
Es mayormente usado en los servidores con gran actividad de datos. En su parte de
gestión de las peticiones, se difiere en Apache en que nginx crea varios procesos, en los
cuales, individualmente, pueden manejar miles de conexiones. Esto se consigue
implementando un mecanismo de loop muy rápido que continuamente supervisa los
eventos de proceso.
Estos eventos dentro del loop, son procesados asincrónicamente, permitiendo que el
trabajo se realice de una forma no-bloqueante.
16
Sergio Fernández Rubio
Trabajo Fin de Grado
2.2. Technical Report 069 (TR-069)
Publicado por el Broadband Forum en el año 2004, su misión es configurar
remotamente los CPE (Customer Premises Equipment) a través de un ACS (AutoConfiguration Server) [9]. También conocido como CWMP (CPE WAN Management
Protocol), este protocolo es diferente en su filosofía al del DHCP66, adoptando un estilo
orientado a comandos (o parámetros) más que a la simple descarga de un archivo de
configuración, aunque esto último también lo incluye en su especificación.
Figura 7: Ejemplo de despliegue de TR-069
Se basa en unos protocolos SOAP/HTTP (Intercambio de mensajes con esquema SOAP
basada en el conocido protocolo HTTP), en el que estos parámetros son enviados. Estos
parámetros son el modelo de datos con el que el ACS trabaja. Como estándar, este
modelo de datos tiene un prefijo en común: Device e InternetGatewayDevice.
Cualquier fabricante puede elegir cuál usar, pero debe ser consistente al usarlo.
Figura 8: Ejemplo de transacción entre CPE y ACS
17
Sergio Fernández Rubio
Trabajo Fin de Grado
Como servicios generales del TR-069 tenemos:
Gestión y configuración automática de los servicios en un CPE
Configuración remota de un CPE
Gestión de firmware
Gestión de versiones
Actualización de la gestión y de control de la ejecución
Log de análisis dinámico y mensajes
Diagnósticos
Conectividad y control de servicios
Pasaremos, a continuación, a hablar del estado de la técnica en servidores de
autoconfiguración.
2.2.1. ACS
Tenemos mucha variedad de soluciones software para el correcto funcionamiento del
ACS (Auto-Configuration Server), pero muchas de ellas son proyectos descontinuados.
Hablaremos de los que están actualmente en desarrollo, tanto Open Source como
privativos.
2.2.1.a. GenieACS
Proyecto de Zaid Abdulla, con la mayor comunidad de usuarios de entre todos los
proyectos Open Source. Su principal objetivo es el rendimiento y la optimización,
usando medios concurrentes y nuevas tecnologías como Node.js, Redis, y MongoDB.
También tiene una modalidad de pago [10].
Figura 9: Logo de GenieACS
Diseñada también para facilitar el diseño de nuevas aplicaciones, forma parte de un
repositorio en GitHub [11] y existen varios forks que el autor aprueba y recomienda
[12]. Además, consta de una API muy completa y accesible para establecer parámetros
de un CPE, presets estáticos, hacer búsquedas de CPEs y borrado de elementos.
Consta de una GUI que desarrolla en Rails, también cuenta con 3 motores, cada uno
encargado de tres puertos por los que los CPE se comunican con el ACS, implementado
en Node.js, y dos bases de datos, una MongoDB, que es la encargada de guardar toda
la información necesaria de cada router conectado, y otra Redis que es la encargada de
guardar los datos de la capa de caché.
18
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 10: Gráficos de monitorización en la pantalla principal de GenieACS
2.2.1.b. Easycwmp
Es el único Open Source que actualmente está soportando la plataforma OpenWRT.
Proveniente del proyecto (ya no mantenido) freecwmp, está siendo desarrollado por
PIVA Software. Su objetivo es ser fiel al estándar TR-069 [13].
Figura 11: Logo de EasyCwmp
El diseño de EasyCwmp incluye dos partes:
El núcleo de EasyCwmp: Contiene el motor de comunicación con el ACS, que
está siendo desarrollado en C.
Los scripts de EasyCwmp: Son una colección de scripts que ejecutan métodos
del ACS (get, set, add, delete, apply setting, download file, upgrade firmware,
reboot…) que están siendo desarrollados en script ash.
19
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 12: Esquema de funcionamiento de EasyCwmp
Otro objetivo que quiere cumplir EasyCwmp es separar el motor de EasyCwmp escrito
en C, del script en ash, para que añadir nuevas funcionalidades sea sencillo.
2.2.1.c. AXESS.ACS
Principal producto de la empresa Axiros. Es un software privativo, pero muy avanzado y
dispuesto a superarse a sí mismo [14].
Figura 13: Logo de AXESS.ACS
20
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 14: Pantalla principal de AXESS.ACS
Cuenta con las siguientes funcionalidades, según la misma empresa:
Mantenimiento remoto de CPEs
Aprovisionamiento instantáneo y sin necesidad de configurar paso a paso el
router
Rápida monitorización, alta tasa de muestreo
En completa conformidad con el estándar TR-069
Portal de servicio para el cliente tipo self-service
Gestión del firmware inteligente
Gestión de la seguridad
Múltiples protocolos NBI, extensibles
Interoperabilidad
Permisos para añadir, ver, cambiar y borrar
Dispone servicios de email, syslog, XML-RPC, SOAP, clientes JMS
Más de 100 lenguajes
Sistema de autorización customizable
Operaciones en masa programadas
Habilidad de operaciones multi-step:
Instalación rápida en sistemas Linux como un paquete
Soporta también Solaris
21
Sergio Fernández Rubio
Trabajo Fin de Grado
Servidor de aplicación incluyendo bases de datos SQL
Posibilidad de agrupar jerárquicamente por CPEs
Cuenta con grandes socios como ZyXEL, una empresa de fabriación de routers,
principalmente en tecnología DSL
2.2.1.d. Unified Device Management Platform de AVSystem
Principal producto de la empresa AVSystem. Es un potente servicio de
autoconfiguración basado en TR-069, que promete autoconfigurar todo tipo de
dispositivo, de cualquier fabricante, con cualquier proocolo, en un gran número de
dispositivos [15].
Figura 15: Logo de AVSystem
Dispone de las siguientes funcionalidades principales:
Activación automática de servicio
Portal para clientes
Módulos autoadministrados
Reportes y monitorización proactiva
Arquitectura basada en tareas y organización en grupos
Interfaz unificada
Soporte para dispositivos IoT, M2M y servicios basados en nube
Servicio de localización geográfica
22
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 16: Vistazo de la aplicación en su modo de localización de dispositivos
Disfruta de grandes socios como SagemCom, Vodafone, Netia, AlbTelecom o
Grandstream.
2.3. Lenguajes de programación
El abanico de lenguajes de programación para desempeñar la tarea de crear los
archivos de configuración, proveer de Internet al cliente, e insertarlo en la base de
datos de tickets es muy amplio. Es por ello que intentaremos resumir las diferentes
opciones que tendremos a nuestra disposición, y más adelante, en la explicación de la
tarea, explicaremos por qué hemos elegido este/estos lenguajes.
2.3.1. R
R es un lenguaje de programación orientado al análisis y procesamiento de datos. Es un
Proyecto GNU, similar al lenguaje S (de donde provino). Este último, S, fue desarrollado
en el antiguo Bell Laboratories por John Chambers y sus compañeros. R nació a partir
de R Robert Gentleman y Ross Ihaka, miembros del Departamento de Estadística de la
Universidad de Auckland, en Nueva Zelanda [16].
23
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 17: Logo de R
R es un lenguaje Orientado a Objetos, y bajo este complejo término se esconde la
simplicidad y flexibilidad de R. La sintaxis de R es simple e intuitiva, con lo que trabajar
con él se hace fácil una vez que te acostumbras. R parte de lenguajes de bajo nivel,
esencialmente C y Fortran.
Orientado a Objetos significa que las variables, datos, funciones o resultados se
guardan en la memoria activa del computador en forma de objetos con un indicador
específico. El usuario puede modificar o manipular estos objetos con operadores
(aritméticos, lógicos, y comparativos) y funciones (que a su vez son objetos).
Figura 18: Pantalla principal de RGui para Windows
R es un lenguaje interpretado, no compilado, lo cual es muy útil a la hora de ejecutar
scripts, sin tener que compilar todo el código. Como facilidades que incluye, según la
misma R Foundation [17], son las siguientes:
Optimizado y efectivo manejo de datos y de almacenamiento
Una suite de operadores para trabajar con arrays, particularmente matrices
Una colección integrada de herramientas para el análisis de datos
Herramientas gráficas para el análisis de datos
Un buen desarrollado, simple y efectivo lenguaje de programación que incluye
24
Sergio Fernández Rubio
Trabajo Fin de Grado
condicionales, iteradores, funciones diseñadas por el usuario, y herramientas de
entrada y salida.
IDE desarrollado enteramente para R: RStudio
Como contra, tiene la pega de que usa muchos recursos, y es más ineficiente,
comparativamente hablando, que otros lenguajes de programación. Por eso se han
creado paquetes para R que recodifican parte del código, usando R, para hacerlo más
veloz. Ejemplos son pqR, renjin, FastR, Riposte, RevoScaleR (comercial) y Foreach
(comercial).
La gran ventaja sobre los demás lenguajes es la facilidad del tratamiento de la
información, el análisis de datos, y la incorporación de nuevos paquetes (o librerías)
para el uso dentro del sistema. También el repositorio de paquetes R es mucho más
grande que las de los demás lenguajes. Los más usados y conocidos son dplyr, plyr,
data.table, stringr, zoo, ggvis, lattice, ggplot2, caret… entre muchos otros.
2.3.2. Python
Python es un lenguaje interpretado de alto nivel, con semántica dinámica [18]. Es
también un lenguaje con orientación a objetos, como ya hemos explicado antes en el
apartado en el que hemos hablado de R. Es también un lenguaje en el que la sintaxis es
sencilla, aunque no tanto como la de R, pero es por ello un lenguaje más potente para
su uso en entornos complejos y costosos en cuanto a uso de recursos.
Figura 19: Logo de Python
Python es un lenguaje multiuso, nacido en 1991 de la mano de Guido Van Rossum, no
dependiendo de ningún lenguaje auxiliar. Su objetivo se centra en la productividad y
legalidad del código. Tiene un buen apoyo por parte de la comunidad en sitios como
Stackoverflow, en listas de correo y documentación base.
Es de resaltar que es uno de los pocos lenguajes en los que la indentación del código
realmente tiene efecto en la ejecución. El debugging tiene por pro en Python que el
código escrito es sencillo de debugear debido a herramientas internas del lenguaje.
Python, en comparación a R, tiene una curva de aprendizaje menor, y es por esto que
es un buen lenguaje para principiantes en programación.
25
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 20: Ejemplo de código en Python
Observamos su indentación y la inexistencia de corchetes
Hay diferentes IDEs para trabajar con Python, entre ellos Spyder, IPython Notebook,
Roden, PyCharm, WingIDE, PyDev… Sus librerías más famosas incluyen pandas,
requests, scrapy, wxPython, NumPy, SciPy, Selenium… entre muchos otros.
2.3.3. Java
Java es un lenguaje interpretado, fuertemente tipado, y de más bajo nivel que R o
Python [19].
Figura 21: Logo de Java
Nacido en 1995 por manos de James Gosling, que trabajaba en Sun Microsystems. La
sintaxis del lenguaje deriva mucho de C y C++, pero es un lenguaje de mayor nivel que
éstos últimos.
Los IDEs más famosos para trabajar con Java son Eclipse, NetBeans, IntelliJ, Android
Studio, BlueJ, JDeveloper…
La clara desventaja frente a los demás lenguajes es que para escribir un mismo código
26
Sergio Fernández Rubio
Trabajo Fin de Grado
en Java que en Python (o R) se necesitan muchas más líneas de código. Esto se hace
evidente cuando queremos leer o escribir datos en disco. En Python o R, es una simple
línea, mientras que Java, aparte de que tiene muchas formas de leer/escribir a disco,
necesita entre 10 y 20 líneas [20].
Figura 22: Entorno Eclipse de desarrollo Java
La ventaja principal de Java es la interoperatividad entre distintos sistemas operativos y
la velocidad de ejecución, que en muchos casos es más rápida que en Python o R.
También tiene ventajas en cuanto al manejo de la concurrencia, ya que contiene
muchas herramientas nativas para su fácil manejo.
2.4. Markdown
Markdown es un lenguaje de marcado ligero creado por John Gruber y Aaron Swartz,
que trata de conseguir la máxima legibilidad y facilidad de publicación en Internet,
usando texto plano [21]. El formato de salida son documentos XHTML bien formados.
Fue escrito originalmente en Perl, pero ha sido escrito en multitud de lenguajes de
programación, incluyendo PHP, Python, Ruby, Java, Common Lisp, R…
No existe ningún estándar creado más allá del que publicó Gruber en su primera
versión en Perl, y por eso importa relativamente poco en la tecnología que se use,
usándose la más cómoda para el programador (normalmente, según el lenguaje
utilizado)
2.5. Bases de Datos
Más y más información es generada por todo el mundo cada día. La cantidad de
información que se genera cada día es del orden de los Exabytes (que equivale a- de bytes). Es de esperar que los sistemas de recolección de
27
Sergio Fernández Rubio
Trabajo Fin de Grado
datos sean potentes y ágiles a la hora de manejar esos datos, y por eso aquí
investigaremos superficialmente las tecnologías principales a la hora de elegir una base
de datos.
2.5.1. Soluciones SQL
Es el gran conocido amigo de las bases de datos. Sus siglas significan Structured Query
Language, y es un lenguaje declarativo de acceso a bases de datos relacionales. Fue
creado en el 1974 por Donald D. Chamberlin mientras trabajaba en IBM [22].
Figura 23: SQL
Aunque SQL es un estándar que ha ido evolucionando en el tiempo, este es voluntario,
que quiere decir, que cada empresa puede crear una sintaxis diferente basándose en el
estándar actual. Por ello, vamos a citar varios ejemplos de soluciones SQL:
2.5.1.a. MySQL
Creada por MySQL AB, una compañía sueca, y mantenida por Oracle Corporation, es
una base de datos relacional Open Source, que en Julio de 2013 alcanzó el puesto
número dos en popularidad mundial [23]. Es el componente central en aplicaciones
web LAMP (Linux, Apache, MySQL, Perl/PHP/Python).
Figura 24: Logo de MySQL
MySQL está escrito en C y C++, y el parser SQL está escrito en yacc, aunque usa un
analizador léxico propio de MySQL. Es multiplataforma, y tiene un extensivo manual a
disposición en su web, donde se pueden encontrar toda la teoría necesaria y también
toda clase de ejemplos prácticos. Además, se puede obtener soporte vía Stackoverflow,
canales IRC y en demás foros, así como un soporte de pago.
28
Sergio Fernández Rubio
Trabajo Fin de Grado
Como funcionalidades, incluye:
Soporte inter-plataforma
Amplio subconjunto del lenguaje SQL
Posibilidad de selección de mecanismos de almacenamiento
Transacciones y claves foráneas
Conectividad segura
Replicación
Búsqueda e indexación de campos de texto
Aunque originalmente no fuera tan robusto como otros lenguajes SQL, se ganó a los
programadores por su facilidad y simpleza, y fue más adelante cuando completaron
todas las operaciones más complejas de los sistemas SQL, tales como las transacciones.
2.5.1.b. PostgreSQL
Base de datos Open Source, multiplataforma [24]. No es manejado por ninguna
empresa, sino que es dirigido por una comunidad de desarrolladores. Tiene más de 15
años de edad, y su arquitectura ha sido exhaustivamente probada y revisada.
Figura 25: Logo de PostgreSQL
Utiliza un modelo cliente/servidor y usa multiprocesos en vez de multihilos para
garantizar la estabilidad del sistema, ya que un fallo en uno de los procesos no afectará
el resto.
Se descompone entre los siguientes módulos:
Aplicación cliente: Es la aplicación cliente que utiliza como administrador de
bases de datos. La conexión ocurre vía TCP/IP o sockets locales.
Demonio postmaster: Es el proceso principal de PostgreSQL. Escucha por un
puerto o socket, para establecer conexiones entrantes de clientes. También se
encarga de crear procesos hijos que explicaremos más adelante.
29
Sergio Fernández Rubio
Trabajo Fin de Grado
Ficheros de configuración: Los 3 principales son postgresql.conf, pg_hba.conf y
pg_ident.conf.
Procesos hijos: Se encargan de autenticar a los clientes, gestionar sus consultas
y mandar los resultados a las aplicaciones clientes.
Memoria compartida caché: Usada por PostgreSQL para almacenar datos en
caché.
Write-Ahead Log (WAL): Componente encargado de asegurar la integridad de
los archivos.
PostgreSQL ha sido un gran proyecto durante años por su capacidad para
autogestionarse mediante una comunidad amplia y de diversas culturas. Según ciertas
estimaciones por parte de COCOMOII, para la versión 9.0.0 de PostgreSQL el coste
total del proyecto asciente hasta aproximadamente los 63 millones de dólares. Y
recordamos, es un proyecto Open Source.
Figura 26: Líneas de código frente a versión de PostgreSQL.
Se observa claramente el gran crecimiento que ha tenido
2.5.1.c. SQLite
Creada por D. Richard Hipp, es una base de datos Open Source creada en agosto del
2000. Es multiplataforma, y es compatible con ACID [25].
Figura 27: Logo de SQLite
30
Sergio Fernández Rubio
Trabajo Fin de Grado
Es la base de datos más usada en el mundo. Y es de resaltar también que está
contenida en una relativamente pequeña (~275 kiB) biblioteca escrita en C. Y contrario
a lo comúnmente encontrado en otras soluciones SQL, no es una base de datos basada
en cliente-servidor, sino que está embedida en el programa final.
¿Por qué es la base de datos más usada en el mundo? Porque la podemos encontrar
en:
Todos los dispositivos Android
Todos los dispositivos iOS
En Firefox, Chrome y Safari
En cada cliente Skype
En cada cliente iTunes
En cada cliente Dropbox
En cada cliente TurboTax y QuickBooks
En la mayoría de sets de televisión y dispositivos reproductores
En la mayoría de servicios multimedia para automóviles
Muchas innumerables más aplicaciones
Y también es la más usada por estos distintivos rasgos:
No hace falta prácticamente set-up. No necesita ninguna instalación, y no se
necesita activar ningún proceso. No hace falta siquiera agregar usuarios. ¿Por
qué? Porque no hay ningún archivo de configuración que configurar, y el
sistema está embedido en la aplicación.
No existe un servidor, ni un proceso del cual depender. Los programas que
quieran acceder a la base de datos, se comunican con el servidor usando un
tipo de comunicación entre procesos, usualmente basado en TCP/IP. No pasan
por ningún servidor, simplemente leen y escriben en los archivos de la base de
datos que están en disco.
Compacta. Cuando está optimizada, con todo activado, ocupa menos de 500KiB
en tamaño. Incluso si no necesitamos ciertas funcionalidades, el tamaño puede
bajar hasta los 300KiB.
Estable en todas las plataformas. Un mismo archivo de base de datos en una
máquina de 32 bits, Little-endian, con Linux, funciona igual que en una máquina
de 64 bits, Big-endian, con Windows.
Valores de tamaño variable. Es de señalar que cuando creas una columna en la
base de datos, si por ejemplo la creas como un tipo VARCHAR(100), si en la
primera fila de esa columna creas un carácter de longitud 5, en disco sólo se
guardarán esos 5 caracteres que has introducido, no 100. Esto es lo contrario a
lo que hacen la mayoría de bases de datos.
31
Sergio Fernández Rubio
Trabajo Fin de Grado
2.5.2. Soluciones NoSQL
¿Por qué NoSQL? NoSQL nació a partir de compañías como Google, Facebook, Amazon
y LinkedIn, para superar las limitaciones de las bases de datos relacionales (SQL) para el
uso de modernas aplicaciones web. Está ampliamente relacionado con las nuevas
tecnologías de Big Data [26].
Figura 28: Familia de bases de datos NoSQL
No hace mucho, 1.000 usuarios para una aplicación eran muchos, y 10.000 se estimaba
como caso extremo. Pero en poco tiempo, hasta llegar a hoy,- personas
se conectan a internet y pasan pasan online sobre unas- horas al mes, y
esto seguirá creciendo día a día.
Esquemas relacionales y no relacionales son muy diferentes. En el modelo relacional
separa los datos en muchas tablas interrelacionadas, pero conforme se va agrandando
la base de datos, la información que se debe presentar a la aplicación tiene que ser
recolectada de muchas tablas. Por el contrario, el modelo NoSQL agrega contenidos de
diferentes documentos y las presenta juntas. A pesar de que esto gasta más memoria,
ya no hay esta restricción porque el modelo NoSQL permite múltiples nodos donde
alojar las partes de la base de datos.
2.5.2.a. MongoDB
Nacida en 2009 por la compañía de software 10gen, es un sistema de bases de datos
Open Source y multiplataforma orientado a documentos [27]. Es la solución líder de
bases de datos NoSQL. El formato en que MongoDB guarda estructuras es dinámico, y
lo llama BSON (Binary JSON).
32
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 29: Logo de MongoDB
¿Por qué es tan popular MongoDB?
Básicamente, por su agilidad. Antes de existir este tipo de bases de datos, era
aceptable pasarse meses planeando una aplicación y su esquema de datos asociado,
desarrollándolo, y tras esto, nunca más se modificaría. Vivimos en la era de la Big Data,
y debemos constantemente reinventar nuestras aplicaciones mientras conseguimos
más y más datos.
También, es muy popular porque es muy sencilla de aprender y de manejar. Tiene una
estructura fácil de escalar, y la misma empresa ofrece cursos de formación para todo
tipo de profesionales y de usos: La mongoDB University.
Figura 30: Interesante comparativa entre una consulta en MySQL frente a la misma en MongoDB
2.6. Routers
También conocidos como enrutadores, o encaminadores de paquetes, es un dispositivo
que proporciona conectividad a nivel de red (o nivel tres, según el modelo OSI).
33
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 31: Modelo tradicional de un router
Para ser considerado un router, debe conectar dos o más líneas de datos de diferentes
redes. Cuando un paquete llega por uno de los puertos de entrada, el router lee la
dirección del paquete para determinar por qué salida deberá salir, usando una tabla de
enrutamiento o unas políticas basadas en protocolos de enrutamiento.
Aunque hay muchas marcas de fabricantes de routers, hablaremos muy brevemente de
dos principales en el mundo del networking:
2.6.1. Cisco Systems Inc.
Cisco Systems, Inc. es una multinacional americana, centralizada en San Jose, California
[28]. Nacida en 1984 por Leonard Bosack, y su mujer Sandy Lerner, diseña, fabrica y
vende equipos de red. Es el líder en soluciones de redes para Internet, ya que el 85%
del tráfico global pasa por dispositivos Cisco.
Figura 32: Logo de Cisco
Cisco, para incentivar el uso de su tecnología y para certificar a los conocedores de ella,
creó los llamados Cisco Careers, que son exámenes dirigidos a los profesionales del
sector, en cinco diferentes niveles: Recién llegado, socio, profesional, experto y
arquitecto. Cada una de las ramas está subdividida en varias especializaciones.
34
Sergio Fernández Rubio
Trabajo Fin de Grado
2.6.2. MikroTik Ltd.
MikroTik Ltd. es un fabricante letón de equipos de redes [29]. Fundada en 1995, se
diferencia fundamentalmente por ser una alternativa económica a los caros
dispositivos de red actuales.
Figura 33: Logo de MikroTik
Es notable destacar también que, aparte de comercializar dispositivos de red al
completo, vende también las RouterBOARD, que son circuitos integrados, preparados
para ser montados en cualquier lugar.
MikroTik también dispone de sus propias certificaciones, en las que en toda su oferta
incluyen seis. Uno de iniciación, y los otros cinco de especialización.
2.6.3. Juniper Networks
Juniper Networks es una multinacional dedicada a sistemas de redes y seguridad,
fundada en 1996 por Pradeep Sindhu, con sede en California [30]. Sus productos
incluyen routers, switches, software de control de redes, productos de seguridad de
redes y tecnología SDN.
Figura 34: Logo de Juniper Networks
Juniper originalmente estuvo especializado en core routers, es decir, en routers
diseñados para operar en la backbone de internet. Actualmente también diseñan
routers para ISPs, y productos de seguridad. Y recientemente se han enfocado en el
desarrollo de productos SDN (Software-Defined Networking).
35
Sergio Fernández Rubio
Trabajo Fin de Grado
2.7. XML
Sus siglas significan, en inglés, eXtensible Markup Language, o en español, “Lenguaje
de Marcas Extensible”, es un lenguaje de marcas desarrollado por el W3C (World Wide
Web Consortium) que define una serie de reglas para codificar documentos, de forma
que sea fácilmente leído por humanos, y también sencillo de parsear para las máquinas
[31].
Figura 35: Logo de XML
El objetivo de diseño de XML fue la simplicidad, generabilidad y usabilidad para su uso
en Internet. Es un formato de texto con mucho soporte vía Unicode. Aunque fue
diseñado con el objetivo de formar documentos, está ampliamente usado para la
representación de estructuras de datos arbitrarias.
Nació a partir del lenguaje de marcas SGML. De él también nació en un principio el
lenguaje HTML [32]. Las principales diferencias que tiene con su hermano HTML es que
las marcas (o tags) en HTML ya están definidas, mientras que en XML esas marcas no
están predefinidas, y puedes definir tú mismo una. Esto es lo que hacen muchos
fabricantes de routers, creando su propio “vocabulario” de marcas XML, creando así un
nuevo namespace.
Namespaces
¿Qué son los namespaces? Es una cuestión que surgió al querer unificar ciertos
documentos en que se usaban las mismas marcas para diferentes elementos. Para
evitar eso, en cada marca, le precede un sufijo especificativo.
Cuando usamos esos prefijos en XML, un namespace debe definirse para el prefijo.
Esto se debe definir por un atributo xlmns en la primera marca de un elemento, o
también otra forma es declararlos como el root del XML.
Si declaramos un namespace con una URI (Universal Resource Identifier) nos
ahorraremos entonces declarar un prefijo para cada elemento que nos encontremos.
XPath
No querríamos terminar sin conocer un poco más XPath, el lenguaje de búsqueda de
información para documentos XML. XPath usa expresiones para seleccionar nodos,
muy parecidas a las expresiones de rutas con las que se trabaja con un sistema
operativo común.
36
Sergio Fernández Rubio
Trabajo Fin de Grado
Ejemplos de expresiones:
/librería/libro[1] : Selecciona el primer elemento libro que es hijo del elemento
librería
/librería/libro[position()<3] : Selecciona los dos primeros libros que son hijos del
elemento librería
//título[@lengua='es'] : Selecciona todos los elementos título que contienen un
atributo llamado “lengua” con un valor de “es”
2.8. ¿Por qué se ha elegido la opción propuesta?
A lo largo del capítulo dos se ha realizado un recorrido por una serie de herramientas
alternativas con las que trabajar con servidores TFTP y HTTP con DHCP Option 66. Las
distintas tecnologías de ACS para el Technical Report 069, los diferentes lenguajes de
programación para conectar con las distintas bases de datos y realizar una interfaz
sencilla para el usuario. También hemos visto formas de trabajar con lenguajes de
marcas para documentación, así como el estado actual de las bases de datos,
importantes marcas de routers, etc. Por último, hemos mencionado el lenguaje XML. A
continuación explicaremos por qué hemos elegido las opciones propuestas y/o por qué
hemos necesitado hablar del estado del arte de estas tecnologías:
Para el servidor TFTP, escogimos Xinetd, debido a que era mucho más sencillo
de mantener, consumía menos recursos y se podría alojar en el mismo servidor
en el cual estábamos desarrollando el código, en un Ubuntu Server 14.04.
Para el servidor HTTP, escogimos Apache HTTP Server. Esto es debido a que su
instalación es muy sencilla y no requeríamos ninguna concurrencia. La tasa a la
que un nuevo router de voz se configura es muy baja, y por lo general nunca
habrá concurrencia.
Para el Auto-Configuration Server decidimos usar una opción Open Source,
debido a que el presupuesto no alcanzaba para usar software privativo, ni
interesaba debido al bajo volumen de dispositivos ADSL que íbamos a
implantar. Decidimos escoger GenieACS, que está en auge y su moderna
tecnología asegura que el proyecto seguirá mejorando y optimizándose durante
muchos años.
Para el lenguaje de programación, escogimos R por su facilidad de integración
con todo lo que queríamos hacer. Aparte de que es más sencillo trabajar con
datos y bases de datos (que era lo que fundamentalmente íbamos a hacer, y es
con lo que mejor trabaja R), dispone del módulo Shiny preparado
específicamente para desarrollar páginas web reactivas, así como un paquete
de lenguaje de marcado RMarkdown. La optimización no era un requisito.
Además, hemos usado Python para una parte del código cuando llama al
37
Sergio Fernández Rubio
Trabajo Fin de Grado
sistema de tickets de la empresa. Para recalcar la rapidez del programa aun
usando R, la parte del código escrito en Python es la más costosa en tiempo.
Para el lenguaje Markdown, hemos utilizado RMarkdown, ya que venía
implementado en el mismo lenguaje en que estábamos progamando, y nos
facilitaba mucho las tareas, además de que en todos los demás lenguajes el
código Markdown es prácticamente el mismo.
En cuanto a bases de datos, las que había en la empresa eran o MySQL o
PostgreSQL, así que esas son las principales bases de datos a las que
consultaremos desde R.
Y para los routers, los que se encargan del routing en la empresa son de la
marca MikroTik, que configuramos para el DHCP66, y los routers destinatarios
para clientes eran Tenda y Grandstream.
Por último, usaremos la información adquirida de los documentos XML para
configurar los routers de voz Grandstream, usando el paquete XML de R.
Tras estas explicaciones, procederemos a explicar más a fondo y de forma más práctica
la tecnología utilizada.
38
39
40
Sergio Fernández Rubio
Trabajo Fin de Grado
Capítulo 3. Tecnología utilizada.
Siguiendo con el índice descrito en el capítulo 1, se va a comenzar a exponer el tercer
capítulo. En este apartado se va a desarrollar más profundamente todos los aspectos
relativos a las herramientas utilizadas durante el trabajo.
Esta sección ayudará a comprender todos los aspectos teóricos de las plataformas, su
funcionamiento y se realizarán ejemplos que ayudarán a entender mejor las
tecnologías de forma práctica.
3.1. Xinetd
Como ya explicamos anteriormente, es mucho más que un servidor TFTP, y es conocido
por ser un super-servidor, ya que gestiona los diferentes servidores de cada servicio.
Por eso es que profundizaremos más acerca de los detalles técnicos y sus posibles usos
en una máquina Linux.
Figura 36: Seguridad, ante todo, en xinetd
Xinetd brinda una excelente defensa contra intrusiones, y específicamente conveniente
al reducir los riesgos de ataques DoS (Denial of Service). Permite también corregir los
permisos de acceso a una máquina, si bien puede hacer mucho más que esto.
Los servicios definidos en los archivos de configuración pueden ser divididos en dos
grupos. Los del primer grupo son llamados multihilo, y requieren la creación de un
nuevo servidor de procesos para cada nueva petición de conexión. Tras eso, el nuevo
servidor maneja esa conexión. Para esos servicios, xinetd sigue escuchando para crear
nuevos servidores. Los del segundo grupo incluyen servicios para lo cual el demonio es
responsable de manejar todas esas nuevas peticiones de conexión. Esos servicios se
llaman monohilo, porque xinetd parará de escuchar nuevas peticiones hasta que el
servidor termine.
La principal razón de por qué fue concebido como un super-servidor fue para evitar la
creación masiva de procesos que seguramente estarían en reposo (Ya que siempre
estarían activos incluso sin peticiones de conexión). Además de esto, se sirve de ser un
super-servidor para poder ofrecer servicios de control de acceso y logueo. Asimismo,
se vuelve especialmente interesante porque no está limitado a servicios de servidores,
sino que cualquier persona podría usar xinetd para arrancar servidores de propósito
específico.
41
Sergio Fernández Rubio
Trabajo Fin de Grado
Según la especificación, las opciones para lanzar xinetd son las siguientes [ref
http://linux.die.net/man/8/xinetd]:
-d:
Habilita el modo de debugging.
-syslog syslog_facility:
Habilita el syslog usando la herramienta que le hemos puesto como opción,
escogida entre los siguientes nombes: daemon, auth, user, local[0-7].
-filelog logfile:
Los mensajes se enviarán al fichero elegido.
-f config_file:
Determina el archivo de configuración que xinetd cargará. Por defecto está en
/etc/xinetd.conf.
-pidfile pid_file:
La PID será escrita en el fichero.
-dontfork:
Esta opción hace que xinetd se oculte antes que permanecer activo, si no hay
ningún servicio activo.
-stayalive:
Esta opción hace que xinetd persista incluso si no hay servicios especificados.
-limit proc_limit:
Da lugar a un límite de procesos concurrentes que puede lanzar xinetd contra
otros servidores. Previene contra overflows de tablas.
-logprocs limit:
Da lugar a un límite de servidores concurrentes activos para adquisiciones
remotas del userid.
-version:
Muestra información sobre la versión de xinetd.
-inetd_compat:
Esta opción hace que xinetd lea /etc/inetd.conf en adición a los archivos de
configuración estándar de xinetd.
-cc interval:
Hace que cada tiempo especificado como interval haga una revisión de
consistencia de su estado interno.
Xinetd realiza ciertas acciones cuando recibe ciertas señales. Las acciones asociadas
42
Sergio Fernández Rubio
Trabajo Fin de Grado
con las señales específicas pueden ser redefinidas editando config.h y recompilando.
Son las siguientes:
SIGHUP. Provoca una profunda reconfiguración, que significa que vuelve a leer
el archivo de configuración y termina los servidores cuyos servicios no están
disponibles.
SIGQUIT. Provoca la terminación del programa.
SIGTERM. Termina todos los servidores activos antes de terminar con xinetd.
SIGUSR1. Provoca un estado interno de volcado en /var/run/xinet.dump.
SIGIOT. Provoca una revisión de consistencia de su estado interno, para verificar
que las estructuras de datos no han sido corruptas.
Ejemplo de servidor TFTP
Procederemos a hablar ahora acerca del archivo ubicado en /etc/xinetd.conf. Por lo
general este archivo tiene entradas de la forma:
service
{
...
...
}
Los servicios disponibles podrían ser, entre otros, TFTP, FTP y TELNET. Como dijimos
anteriormente, podemos definir cualquier tipo de servicio, por ejemplo, SMTP, HTTP o
SSH, pero esos servicios se usan en modo standalone debido a que son servicios que
contienen mucho tráfico, ya que xinetd los manejaría de un modo más lento.
El archivo de configuración que generamos, por ejemplo, es el siguiente:
c
service tftp
{
protocol
port
socket_type
wait
user
server
server_args
disable
}
=
=
=
=
=
=
=
=
udp
69
dgram
yes
nobody
/usr/sbin/in.tftpd
/tftpboot
no
Lo creamos en la ubicación /etc/xinetd.d/tftp. A continuación explicaremos el
significado de cada atributo.
El atributo protocol sirve para establecer el tipo de comunicación, entre tcp o
udp. En este caso, el protocolo tftp, por definición, trabaja en udp.
En el atributo port especificamos el puerto en el que queremos que escuche. En
43
Sergio Fernández Rubio
Trabajo Fin de Grado
nuestro caso el 69, ya que es el puerto por definición del protocolo tftp.
En el atributo socket_type especificamos el tipo de socket que manejará el
servidor. Entre las opciones están stream, dgram, raw y seqpacket. Usaremos
dgram ya que será un servicio basado en datagramas.
El atributo wait determina si el servicio es monohilo o multihilo. Si el valor es
yes, el servicio será monohilo, que quiere decir que xinetd arrancará el servidor
y parará de escuchar nuevas peticiones hasta que el servidor muera. Según la
recomendación del desarrollador, para configuraciones udp/dgram se espera
que este atributo sea yes, ya que udp no está orientado a conexión.
El atributo user determina el uid para el proceso del servidor. Si se da un
nombre, ese usuario debe existir en /etc/passwd.
El atributo server determina el programa que ejecutar para este servicio.
El atributo server_args son los argumentos que se pasarán al programa que se
ejecutará. En nuestro caso, para el servidor tftp, será el directorio en donde
nuestro servidor tftp buscará archivos que pidan.
El atributo disable determina si el servicio se deshabilitará o no.
Con esto, ya tendremos nuestro servidor casi listo. Sólo nos falta crear y modificar los
permisos para hacer funcional el directorio /tftpboot.
sudo mkdir /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R nobody /tftpboot
Donde /tftpboot debe coincidir con el directorio que le hayamos pasado como
argumentos al programa en el fichero de configuración de xinetd, y lo mismo sucede
para el usuario nobody.
Tras esto, reiniciaremos el servicio xinetd.
sudo service xinetd restart
Y tras esto, nuestro servidor ya estará completamente listo para funcionar. Vamos a
probarlo.
Primero crearemos un archivo de test para comprobar su funcionalidad, llamado test,
que guardaremos en la carpeta /tftpboot.
44
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 37: Creación del archivo de test
Una vez creado, lo que haremos será ejecutar un cliente tftp. Para nuestra prueba,
usaremos el cliente para Linux llamado tftp. Para conectarnos a nuestro servidor tftp,
lo que haremos será ejecutar tftp seguido de la dirección, para a continuación extraer
el archivo.
Figura 38: Petición de archivo de test vía tftp
Y observamos que se ha transferido correctamente:
Figura 39: Comprobación de archivo recibido
45
Sergio Fernández Rubio
Trabajo Fin de Grado
3.2. Apache HTTP Server
Como ya hemos explicado antes, es uno de los servidores web más veteranos de todo
internet, por ello la documentación abunda muchísimo, y es muy sencillo de instalar.
Procederemos a exponer un ejemplo de instalación cualquiera, bajo un entorno Linux.
El único comando que necesitar para instalarse es:
sudo apt-get install apache2
Con la que ya tendremos nuestro servidor funcionando. Pero para hacer lo que
nosotros queremos, tenemos algunos archivos de configuración que detallamos a
continuación:
Apache2.conf: Configuraciones globales para Apache2
envvars: Variables de entorno establecidas
ports.conf: Directivas que determinan los puertos TCP donde apache escuchará
Entre otros. Así de sencillo.
Ahora bien, ¿cómo creamos esos archivos de configuración que necesitan los routers?
3.3. El entorno de trabajo RStudio, R, y el paquete Shiny
Comenzaremos profundizando el IDE RStudio y con los elementos de programación
debido a que, para explicar el resto, debemos saber cómo funciona R para saber cómo
podemos implementar la creación de los archivos de configuración y las
sincronizaciones con las demás bases de datos. Posteriormente también hablaremos de
Python, ya que también lo hemos usado.
3.3.1. RStudio
RStudio está disponible en su versión de escritorio para Windows, iOS, Debian/Ubuntu
y Fedora/RedHat/openSUSE [33]. En su versión servidor para Debian/Ubuntu,
RedHat/CentOS y openSUSE/SLES, aunque virtualmente se podría hacer en cualquier
SO debido a que tenemos disponible la descarga del código fuente, para instalar desde
él.
Una vez instalado (en el Anexo A se hablará de cómo instalarlo en su versión servidor),
la aparencia es parecida a esta en las diversas plataformas:
46
Sergio Fernández Rubio
Trabajo Fin de Grado
Figura 40: Entorno de trabajo RStudio
En la versión servidor, la GUI sería la misma, sólo que dentro de un navegador, al que
accederíamos a través del puerto 8787 vía HTTP.
En la imagen podemos ver que tenemos una barra superior de herramientas, donde
podremos abrir, cerrar ficheros, editar código por varios métodos de búsqueda y
reemplazo… Muchas opciones, y nos gustaría destacar una.
En Tools, iremos a Global Options. Desde allí encontramos todas las opciones de
configuración para poner a punto nuestro IDE.
Figura 41: Configuraciones Globales de RStudio
47
Sergio Fernández Rubio
Trabajo Fin de Grado
Aquí podremos elegir una versión diferente de R que la instalada, o escoger el
directorio de trabajo por defecto. Después tenemos una serie de opciones, como
guardar el espacio de trabajo al cerrar. Más abajo tenemos otra opción muy
interesante, y es la elección de codificación por defecto. Podremos escoger entre
varias: ISO, UTF, ASCI… Una elección bastante importante según con qué datos estemos
trabajando y en qué sistema operativo.
Volviendo a la pantalla inicial, encontramos en la parte izquierda superior, un editor de
texto, donde escribiremos nuestro código. Más abajo, en la parte izquierda inferior,
encontramos la zona donde ejecutar nuestro código. Allí encontraremos los logs,
resultados, errores y warnings.
Arriba a la derecha nos encontramos, en la parte superior, con una zona donde nos
encontramos el entorno de trabajo, donde se pueden ver todas las asignaciones de
variables que hay en este momento. Podemos ver su tipo e incluso lo que ocupa en
memoria. También podemos ver que contiene otra ventana para seleccionar, donde
encontramos el historial de comandos que hemos introducido en la consola.
En la parte inferior, a la derecha, encontraremos varias funcionalidades. Podemos ver
un listado con los directorios, partiendo desde el directorio de trabajo. Además,
podemos ver los plots resultantes de nuestras operaciones. También podemos en la
siguiente pestaña, trabajar con los paquetes de R, instalándolos, desinstalándalos o
cargándolos en memoria. En la siguiente pestaña tenemos una sección de ayuda para
cuando ejecutamos comandos de solicitud de ayuda para ciertas funciones. La última
pestaña se utiliza para ver contenido web en local, por ejemplo, con Shiny.
Ahora que hemos hecho un repaso al IDE, vamos a profundizar más acerca de R:
3.3.2. R
Como ya hemos explicado antes, R es un lenguaje especialmente enfocado al análisis
de datos, siendo muy sencillo trabajar con información. Hablemos de su paradigma.
R soporta una mezcla de orientación a objetos con programación funcional en los
siguientes sentidos:
Por parte de programación funcional, tenemos:
Funciones de primera clase.
Evaluación perezosa de argumentos (lazy evaluation).
Funciones puras, sin efectos secundarios.
Sin embargo:
No implementa colas de llamadas de optimización (Tail call recursion).
Es sencillo crear funciones impuras.
Por parte de orientación a objetos tenemos:
Tres paradigmas de orientación a objetos: S3 y S4, que son inmutables y dan
48
Sergio Fernández Rubio
Trabajo Fin de Grado
soporte a funciones genéricas, y R5, o clases de referencia, que son mutables,
pues dan soporte a traspasos de mensaje más comunes.
El paradigma S4 está muy influenciado por common lisp (CLOS) y dylan.
Existen paquetes que proveen otros tipos de paradigma de orientación a
objetos, como proto, mutatr, R.oo y OOP.
Sin embargo:
Las herramientas disponibles en R para orientación a objetos proveen poco
desarrollo en su facilidad para implementarlos (también conocido en inglés
como syntactic sugar)
El lenguaje soporta lexical scoping, que explicaremos de la siguiente forma:
Consideremos la siguiente función en R:
f Valor asignado - Extensión
Así vemos que, primeramente, hemos cambiado el contenido del nodo XML al valor
“Valor asignado”. Tras esto, hemos añadido contenido en vez de borrar lo que había
escrito, y hemos añadido el valor " - Extensión". Por último, hemos modificado el
nombre de la marca y ha pasado de llamarse “P2” a “Tag1”.
Por último, explicaremos también más detalladamente la función saveXML() del
paquete:
saveXML(archivo,
file="C:\\Users\\sergi\\Desktop\\archivo.xml",
prefix = ‘’)
En este ejemplo, hemos guardado nuestro archivo que hemos modificado en la misma
localización de donde lo extrajimos. Es de notar que el argumento prefix lo debemos
asignar a un string vacío, ya que de otro modo vuelve a escribir el inicio de fichero XML,
que ya viene por defecto en nuestro archivo.
Conexiones a Bases de Datos
Parte fundamental de nuestro programa son las llamadas a las bases de datos, así que
en esta sección explicaremos las formas de trabajar con ellas.
Depende de la base de datos a la que accedamos, necesitaremos un paquete diferente.
En nuestro caso hemos conectado a bases de datos MySQL y PostgreSQL, así que
explicaremos los paquetes asociados a estas bases de datos.
Para conectar con bases de datos MySQL, tenemos el paquete RMySQL. Un ejemplo de
uso es el siguiente:
Library(RMySQL)
con = 2){
textInput("direccion11", "Dirección de la instalación: ")
}})
output$direccion2 = 2){
textInput("direccion22", "Ciudad: ")
}})
output$direccion3 = 2){
textInput("direccion33", "Región: ")
}})
78
Sergio Fernández Rubio
Trabajo Fin de Grado
En el anterior bloque de texto, tenemos los tres renderUI() por si escogemos una
extensión para un número de cliente mayor a dos, introducir la nueva dirección. Son
reactivos porque deben aparecer sólo si seleccionan una extensión mayor o igual a dos.
output$macSelect = 2){
numeroCliente = 2){
address = 2){
numeroClienteSinExtension = 2){
output$erroresHS 4:
SeleniumTICKETS.TLFN = sys.argv.pop()
SeleniumTICKETS.CC = sys.argv.pop()
SeleniumTICKETS.EMAIL = sys.argv.pop()
SeleniumTICKETS.SURN = sys.argv.pop()
SeleniumTICKETS.NAME = sys.argv.pop()
unittest.main()
93
Sergio Fernández Rubio
Trabajo Fin de Grado
Primero, observamos que, para ejecutar el código, se deben pasar 5 o más argumentos
cuando llamemos a la función. Si se cumple, Haremos un sys.argv.pop() para cada uno
de los argumentos, tras lo cual, llamaremos a la función principal.
Primero hará un setUp(), que se encuentra dentro de la definición de clase de
SeleniumTICKETS. En este setup, creamos un WebDriver de PhantomJS, estableciendo
también su tamaño, así como ciertos parámetros como el tiempo de espera máximo, la
URI principal a la que se deberá de conectar…
A continuación nos encontramos con la función de test_selenium_t_i_c_k_e_t_s(), en
la que haremos toda la parte de webscraping. Primero navegaremos hacia la página
web indicada como la principal de la base de datos de tickets.
Tras esto, haremos una búsqueda por ID de los elementos del Login, y los borraremos
antes de introducir nada. Introduciremos el usuario y la contraseña, y luego haremos
click al botón buscándolo mediante el selector de css, ya que es el único que contiene
el atributo div.aquaSquareMiddle.
Una vez dentro de la página, haremos una búsqueda XML mediante XPath, para
encontrar la imagen del cliente, y hacer click. Después de eso, se abrirá otra página y
haremos click a “Nuevo cliente”.
Tras esto, nos abrirá otra página donde introducir los datos del cliente. La búsqueda de
esos elementos se hace mediante id del nombre del div contenedor (por eso los
nombres son tan largos). Iremos introduciendo los argumentos que le hemos pasado
como parámetros.
Tras terminar, de nuevo le damos al botón de guardar. Y ahora, una vez creado el
cliente, procederemos a subirle el archivo csv de ticket.
Para ello, debemos acceder a la imagen de Configuración, y dentro de él, a
preferencias. Es de notar ahora, que el link que queremos pulsar dentro de
preferencias está desactivado. ¿Por qué? Porque debemos hacer un hover sobre el
elemento div “preferencias”. Esto se consigue con una función llamada ActionChains().
Esperamos a que se abra el desplegable un segundo, tras lo cual ya podremos pulsar
los elementos seleccionados.
Una vez dentro de la importación de tickets por medio del csv, enviamos el archivo de
tickets. Le damos a enviar, y esperamos manualmente cuatro segundos a que finalice la
importación, tras lo cual nos deslogueamos.
En el siguiente bloque de código, explicaremos la creación de los archivos de
configuración Tenda W308R.
94
Sergio Fernández Rubio
Trabajo Fin de Grado
if (input$select == "Sí"){
print("Creando el archivo de configuración”)
incProgress(5/6, detail = "Creando archivo")
if(input$selectRouter == "Tenda W308R"){
tryCatch({
archivo <', archivo)
ids[2] <', archivo) # NTP
ids[4] <', archivo)
ids[5] <', archivo)
ids[6] <', archivo) # Time Zone
ids[8] <', archivo)
ids[9] <', archivo)
ids[10] <', archivo)
ids[11] <', archivo)
ids[12] <', archivo)
103
Sergio Fernández Rubio
ids[13]
ids[14]
ids[15]
ids[16]
ids[17]
ids[18]
ids[19]
ids[20]
ids[21]
ids[22]
ids[23]
ids[24]
ids[25]
ids[26]
ids[27]
ids[28]
ids[29]
ids[30]
ids[31]
ids[32]
ids[33]
ids[34]
ids[35]
ids[36]
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<', archivo)
pmatch('\t\t', archivo) # Time Zone
pmatch('\t\t', archivo)
pmatch('\t\t', archivo)
pmatch('\t\t', archivo)
pmatch('\t\t', archivo)
pmatch('\t\t', archivo) # Puerto 8080
pmatch('\t\t', archivo) # ANTES NO ESTABA ABAJO
pmatch('\t\t', archivo)
pmatch('\t\t', archivo)
pmatch('\t\t', archivo)
pmatch('\t\t', archivo) # ANTES NO ESTABA ABAJO
pmatch('', archivo)
pmatch('\t\t', archivo) # Vocoder 2
pmatch('\t\t', archivo) # Vocoder 3
pmatch('\t\t', archivo) # Vocoder 4
pmatch('\t\t', archivo) # Vocoder 5
pmatch('\t\t', archivo) # Vocoder 6
pmatch('\t\t', archivo) # Vocoder 7
pmatch('\t\t', archivo) # Vocoder 8
pmatch('\t\t', archivo) # DNS
pmatch('\t\t', archivo) # DNS
pmatch('\t\t', archivo) # DNS
pmatch('\t\t', archivo) # DNS
MACGS <XXX"
archivo[l+6] <%s", passwordPPPoETLFN)
archivo[l+5] <XXX"
archivo[l+4] <%s", input$telefonoGS)
archivo[l+3] <%s", ipSIP) # Puede ser de clientes
o empresas
extension <%s", numeroClienteGS)
104
Sergio Fernández Rubio
Trabajo Fin de Grado
archivo[l+1] <XXX"
archivo[l] <%s", passwordLargaSIP)
archivo[l-1] <%s", input$nombreGS)
# Añadimos el resto
archivo[ids[1]] <2" # PPPoE Option
archivo[ids[2]] <XXX"
archivo[ids[4]] <48"
archivo[ids[5]] <8"
archivo[ids[6]] <CET-1CEST2,M3.5.0/02:00:00,M10.5.0/03:00:00"
archivo[ids[8]] <0"
archivo[ids[9]] <0"
archivo[ids[10]] <1"
archivo[ids[11]] <1"
archivo[ids[12]] <1"
archivo[ids[13]] <1"
archivo[ids[14]] <GMT+0BST,M3.5.0,M10.5.0"
archivo[ids[15]] <1"
archivo[ids[16]] <1"
archivo[ids[17]] <0"
archivo[ids[18]] <10"
archivo[ids[19]] <XXX"
archivo[ids[20]] <0"
archivo[ids[21]] <{[6789]xxxxxxxx| x+ | *x+ | *xx*x+
}"
archivo[ids[22]] <1"
archivo[ids[23]] <0"
archivo[ids[24]] <0"
archivo[ids[25]] <%s",
toupper(limpiaMAC(input$macGS)))
archivo[ids[26]] <8"
archivo[ids[27]] <8"
archivo[ids[28]] <8"
archivo[ids[29]] <8"
archivo[ids[30]] <8"
archivo[ids[31]] <8"
archivo[ids[32]] <8"
archivo[ids[33]] <XXX"
archivo[ids[34]] <XXX"
archivo[ids[35]] <XXX"
archivo[ids[36]] <XXX"
tryCatch({
write(archivo, paste0("./archivos-samba-http/", MAC_GS))
system(sprintf("smbclient -U user //XX.XX.XX.XX/httpSRV pass -c \"put %s
%s\"", sprintf("./archivos-samba-http/%s", MAC_GS), MAC_GS))
output$okGS