Esta página estaba en el wiki de oriolrius.cat (2009–2012). La recupero aquí tal como era.
Antecedentes
La integración contínua tiene como objetivo hacer un seguimiento contínuo de los cambios en el código de un proyecto, para detectar fallos o problemas en el momento en el que se realizan, es decir, lograr una detección rápida de errores que evite problemas posteriores. Se trata al fin y al cabo de un control de calidad.
Para realizar una integración contínua de un proyecto es necesario que éste cumpla una serie de requisitos:
- Uso de control de versiones. De esta forma se pueden detectar de forma sencilla cambios en el código, así como qué versión es la que genera problemas
- Construcción automática. El proyecto debe poder compilarse con un sólo comando.
- Testsuite completa. El proyecto debe contar con un conjunto de tests que son los que determinarán sin hay algún tipo de error en el código
Existen también una serie de recomendaciones:
- Commits regulares. De esta forma se evita que las diferentes ramas de desarrollo divergan y se tarde más en detectar problemas
- Cada commit debería compilarse y probarse
- La compilación debería ser rápida. Cuanto antes se compile el código, antes se detectan los fallos
- Las pruebas deberían realizarse en un clon de la máquina en producción.
- Fácil obtención de las últimas versiones, para que sea más fácil probar y por lo tanto detectar problemas
- Todos los desarrolladores deberían poder ver los resultados de las pruebas. De este modo si hay algún problema todo el mundo podrá verlo de forma sencilla.
Objetivos
Los objetivos que se pretenden conseguir utilizando integración contínua son:
- Comprobar la corrección del software
- Comprobar el rendimiento del software
- Que el coste de la implantación del sistema sea reducido.
Ideas/propuesta
Teniendo en cuenta lo comentado en los puntos anteriores, para poder implantar un sistema de integración contínua habría que realizar las siguientes tareas:
- Crear un sistema de construcción del software
- Implantar un servidor de integración contínua
- Desarrollar una testsuite completa, tanto con tests de corrección como de rendimiento.
Profundicemos en cada uno de los puntos
Sistema de construcción de software
Teniendo en cuenta que uno de los objetivos fundamentales es la evaluación del rendimiento y que el player está basado en clutter y que gran parte del rendimiento vendrá determinado por esta librería, puede ser interesante probar también el software con diferentes versiones de clutter. Clutter utiliza jhbuild como sistema de construcción del software, por lo que se podría utilizar el mismo sistema para construir todo el stack de software
Servidor de integración contínua
Existen multitud de aplicaciones para realizar esta tarea (ver http://en.wikipedia.org/wiki/Continuous_integration). Sin embargo, teniendo en cuenta la selección del sistema de construcción indicada en el punto anterior nos interesa algún sistema que se integre fácilmente con jhbuild. jhbuild parte del proyecto Gnome, que está utilizando un sistema de integración contínua (buildbot http://buildbot.net/) y tienen scripts desarrollados para la intergación con jhbuild (http://live.gnome.org/BuildBrigade https://www.ohloh.net/p/jhbuild-buildbot-scripts). Por ello creo que podríamos utilizar este sistema.
Además, hay un par de cuestiones de menor relevancia pero que considero positivas: jhbuild y buildbot están ambos desarrollados en python, con lo cuál todas las herramientas utilizan el mismo lenguaje de programación, y detrás de la integración de jhbuild y buildbot está la gente de igalia, lo cuál implica una cierta 'cercanía' geográfica e idiomática.
Testsuite
Corrección
Python ofrece en la librería estándar un framework para la creación de tests: http://docs.python.org/library/unittest.html
Rendimiento
Aparte de tener en cuenta cuestiones relativas al rendimiento en python http://wiki.python.org/moin/PythonSpeed/PerformanceTips para poder realizar tests de rendiminiento. Para ello hay varias opciones:
- http://docs.python.org/library/profile.html La librería estándar de python ofrece un par de mecanismos de profiling. Esto puede ser útil para depurar el rendimiento, pero es poco útil para hacer un seguimiento del rendimiento en el tiempo
- http://docs.python.org/library/timeit.html La librería estándar también proporciona este módulo que permite medir el tiempo de ejecución de algunas funciones.
- http://guppy-pe.sourceforge.net/#Heapy permite depurar el consumo de memoria
- http://agiletesting.blogspot.com/2004/12/performance-testing-with-pyunitperf.html Framework para la creación de tests de rendiminiento
He encontrado también un artículo interesante de Andy Wingo sobre cómo mejorar el consumo de memoria en python: http://wingolog.org/archives/2007/11/27/reducing-the-footprint-of-python-applications
El problema de todas estas soluciones es que o bien están pensadas para depurar un programa (no hacer un seguimiento en el tiempo) o bien ofrecen información reducida. En resumen, que python no es un lenguaje que permita mucha introspección en cuanto a consumo de tiempo/memoria. Lo más razonable sería utilizar una combinación del framework pyunitperf con timeit, sin embargo, hay que tener en cuenta que esto únicamente nos dará información sobre el tiempo real que tarda la aplicación en realizar determinadas tareas.
Tareas a realizar
- Realizar una testsuite básica de rendimiento para la aplicación.
- Validar si la información que podemos obtener de la testsuite nos parece de interés para realizar la implantación de un sistema de integración contínua
- Implantar/probar buildbot
- Conectar los resultados de la testsuite básica con buildbot
- Crear un módulo jhbuild para el player
- Implantar el sistema de integración contínua en una máquina equivalente a la de producción
- Crear varios entornos con diferentes versiones de clutter/pyclutter (stable, inestable, etc.) para poder evaluar si una modificación en el rendimiento se debe a clutter o al player
- Completar la testsuite para el player
- Implantar