Player en Clutter: integración contínua

Ideas y propuesta para montar integración contínua (jhbuild, buildbot y una testsuite de corrección y rendimiento) en el player hecho con Clutter.

Léela en: CatalàEnglish

Parte 7 de 7Apuntes de Clutter
  1. Conceptos de Clutter
  2. Apuntes sobre Clutter
  3. Instalando Clutter con jhbuild
  4. Snippets de Clutter: D-Bus, GStreamer y ClutterScript
  5. Algunas notas sobre el desarrollo con Clutter
  6. Player en Clutter y DBUS
  7. Player en Clutter: integración contínua

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:

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

  1. Realizar una testsuite básica de rendimiento para la aplicación.
  2. 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
  3. Implantar/probar buildbot
  4. Conectar los resultados de la testsuite básica con buildbot
  5. Crear un módulo jhbuild para el player
  6. Implantar el sistema de integración contínua en una máquina equivalente a la de producción
  7. 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
  8. Completar la testsuite para el player
  9. Implantar