delivery - continuous integration python

Integración continua "bonita" para Python

Question

Esta es una pregunta ligeramente ... vana, pero la salida de BuildBot no es particularmente agradable de ver.

Por ejemplo, en comparación con ..

• phpUnderControl
• Jenkins
  • Hudson
• CruiseControl.rb

BuildBot otros, BuildBot parece más bien ... arcaico

Actualmente estoy jugando con Hudson, pero está muy centrado en Java (aunque con esta guía , me pareció más fácil de configurar que BuildBot, y produjo más información)

Básicamente: ¿hay algún sistema de integración continua dirigido a python, que produzca muchos gráficos brillantes y "me gusta"?

Actualización: Desde esta vez, el proyecto Jenkins ha reemplazado a Hudson como la versión comunitaria del paquete. Los autores originales también se han mudado a este proyecto. Jenkins ahora es un paquete estándar en Ubuntu / Debian, RedHat / Fedora / CentOS, y otros. La siguiente actualización sigue siendo esencialmente correcta. El punto de partida para hacer esto con Jenkins es diferente.

Actualización: Después de probar algunas alternativas, creo que me quedaré con Hudson. Integrity fue agradable y simple, pero bastante limitada. Creo que Buildbot es más adecuado para tener numerosos build-slaves, en lugar de que todo funcione en una sola máquina como la que estaba usando.

Configurar Hudson para un proyecto de Python fue bastante simple:

• Descarga Hudson desde http://hudson-ci.org/
• java -jar hudson.war con java -jar hudson.war
• Abra la interfaz web en la dirección predeterminada de http://localhost:8080
• Vaya a Administrar Hudson, complementos, haga clic en "Actualizar" o similar
• Instalar el plugin de Git (tuve que configurar la ruta de git en las preferencias globales de Hudson)
• Cree un nuevo proyecto, ingrese el repositorio, los intervalos de sondeo SCM, etc.
• Instale nosetests través de easy_install si aún no lo está
• En el paso de compilación, agrega nosetests --with-xunit --verbose
• Marque "Publicar el informe de resultados de la prueba JUnit" y establezca "XML de informes de prueba" en **/nosetests.xml

Eso es todo lo que se requiere. Puede configurar notificaciones por correo electrónico, y los complementos valen la pena. Algunos que estoy usando actualmente para proyectos de Python:

• Complemento SLOCCount para contar las líneas de código (¡y graficarlo!) - necesita instalar sloccount separado
• Violations para analizar la salida de PyLint (puede configurar umbrales de advertencia, graficar el número de violaciones sobre cada compilación)
• Cobertura puede analizar el resultado de coverage.py. Nosetest puede recopilar cobertura mientras ejecuta sus pruebas, usando nosetests --with-coverage (esto escribe la salida a **/coverage.xml )

Answer 1

Atlassian''s Bamboo también merece la pena echarle un vistazo. Toda la suite Atlassian (JIRA, Confluence, FishEye, etc.) es bastante dulce.

Answer 2

Consideraría CircleCi : tiene un gran soporte de Python y una salida muy bonita.

Answer 3

Es posible que desee comprobar Nose y el complemento de salida Xunit . Puede hacer que ejecute las pruebas de su unidad y verificaciones de cobertura con este comando:

nosetests --with-xunit --enable-cover

Eso será útil si desea utilizar la ruta Jenkins, o si desea utilizar otro servidor CI que sea compatible con los informes de prueba JUnit.

Del mismo modo, puede capturar la salida de pilyl utilizando el plugin de violaciones para Jenkins

Answer 4

Hemos tenido un gran éxito con TeamCity como nuestro servidor de CI y usando nose como nuestro corredor de prueba. El plugin de Teamcity para pruebas en la nariz te da cuenta de aprobado / reprobado, muestra legible para la prueba fallida (que puede enviarse por correo electrónico). Incluso puede ver detalles de las fallas de prueba mientras la pila se está ejecutando.

Por supuesto, admite cosas como correr en múltiples máquinas, y es mucho más fácil de configurar y mantener que buildbot.

Answer 5

Hemos usado bastante mordido. Es bonito y se integra bien con Trac, pero es un dolor de cabeza personalizarlo si tiene un flujo de trabajo no estándar. Además, simplemente no hay tantos complementos como hay para las herramientas más populares. Actualmente estamos evaluando a Hudson como reemplazo.

Answer 6

La página de la cascada de Buildbot puede embellecerse considerablemente. Aquí hay un buen ejemplo http://build.chromium.org/buildbot/waterfall/waterfall

Answer 7

La señal es otra opción. Puede obtener más información al respecto y ver un video también here .

Answer 8

No sé si lo haría: Bitten está hecho por los tipos que escriben Trac y está integrado con Trac. Apache Gump es la herramienta de CI utilizada por Apache. Está escrito en Python.

Answer 9

Poco descargo de responsabilidad, de hecho tuve que crear una solución como esta para un cliente que quería una forma de probar e implementar automáticamente cualquier código en un git push además de administrar los tickets de problemas a través de notas git. Esto también me llevó a trabajar en el proyecto AIMS .

Uno podría simplemente configurar un sistema de nodo desnudo que tenga un usuario de compilación y administrar su compilación a través de make(1) , expect(1) , crontab(1) / systemd.unit(5) e incrontab(1) . Uno podría incluso ir un paso más allá y usar ansible y apio para compilaciones distribuidas con una tienda de archivos gridfs / nfs.

Aunque, no esperaría que nadie más que un tipo de UNIX de Barbanegra o un ingeniero / arquitecto de nivel Principio lleguen tan lejos. Es una buena idea y una experiencia de aprendizaje potencial ya que un servidor de compilación no es más que una forma de ejecutar arbitrariamente tareas escritas de manera automatizada.

Answer 10

Si está considerando una solución alojada de CI y está haciendo código abierto, también debe buscar en Travis CI : tiene una integración muy buena con GitHub. Si bien comenzó como una herramienta de Ruby, han agregado el soporte de Python hace un tiempo.

Answer 11

Supongo que este hilo es bastante viejo, pero aquí está mi opinión con Hudson:

Decidí ir con pip y configurar un repositorio (el doloroso para conseguir un puesto de trabajo pero agradable), que hudson carga automáticamente con unas pruebas exitosas. Aquí está mi guión rudo y listo para usar con un guión de ejecución de hudson config como: /var/lib/hudson/venv/main/bin/hudson_script.py -w $ WORKSPACE -p my.package -v $ BUILD_NUMBER, solo ponga ** / coverage.xml, pylint.txt y nosetests.xml en los bits de configuración:

#!/var/lib/hudson/venv/main/bin/python
import os
import re
import subprocess
import logging
import optparse

logging.basicConfig(level=logging.INFO,
                    format=''%(asctime)s %(levelname)s %(message)s'')

#venvDir = "/var/lib/hudson/venv/main/bin/"

UPLOAD_REPO = "http://ldndev01:3442"

def call_command(command, cwd, ignore_error_code=False):
    try:
        logging.info("Running: %s" % command)
        status = subprocess.call(command, cwd=cwd, shell=True)
        if not ignore_error_code and status != 0:
            raise Exception("Last command failed")

        return status

    except:
        logging.exception("Could not run command %s" % command)
        raise

def main():
    usage = "usage: %prog [options]"
    parser = optparse.OptionParser(usage)
    parser.add_option("-w", "--workspace", dest="workspace",
                      help="workspace folder for the job")
    parser.add_option("-p", "--package", dest="package",
                      help="the package name i.e., back_office.reconciler")
    parser.add_option("-v", "--build_number", dest="build_number",
                      help="the build number, which will get put at the end of the package version")
    options, args = parser.parse_args()

    if not options.workspace or not options.package:
        raise Exception("Need both args, do --help for info")

    venvDir = options.package + "_venv/"

    #find out if venv is there
    if not os.path.exists(venvDir):
        #make it
        call_command("virtualenv %s --no-site-packages" % venvDir,
                     options.workspace)

    #install the venv/make sure its there plus install the local package
    call_command("%sbin/pip install -e ./ --extra-index %s" % (venvDir, UPLOAD_REPO),
                 options.workspace)

    #make sure pylint, nose and coverage are installed
    call_command("%sbin/pip install nose pylint coverage epydoc" % venvDir,
                 options.workspace)

    #make sure we have an __init__.py
    #this shouldn''t be needed if the packages are set up correctly
    #modules = options.package.split(".")
    #if len(modules) > 1: 
    #    call_command("touch ''%s/__init__.py''" % modules[0], 
    #                 options.workspace)
    #do the nosetests
    test_status = call_command("%sbin/nosetests %s --with-xunit --with-coverage --cover-package %s --cover-erase" % (venvDir,
                                                                                     options.package.replace(".", "/"),
                                                                                     options.package),
                 options.workspace, True)
    #produce coverage report -i for ignore weird missing file errors
    call_command("%sbin/coverage xml -i" % venvDir,
                 options.workspace)
    #move it so that the code coverage plugin can find it
    call_command("mv coverage.xml %s" % (options.package.replace(".", "/")),
                 options.workspace)
    #run pylint
    call_command("%sbin/pylint --rcfile ~/pylint.rc -f parseable %s > pylint.txt" % (venvDir, 
                                                                                     options.package),
                 options.workspace, True)

    #remove old dists so we only have the newest at the end
    call_command("rm -rfv %s" % (options.workspace + "/dist"),
                 options.workspace)

    #if the build passes upload the result to the egg_basket
    if test_status == 0:
        logging.info("Success - uploading egg")
        upload_bit = "upload -r %s/upload" % UPLOAD_REPO
    else:
        logging.info("Failure - not uploading egg")
        upload_bit = ""

    #create egg
    call_command("%sbin/python setup.py egg_info --tag-build=.0.%s --tag-svn-revision --tag-date sdist %s" % (venvDir,
                                                                                                              options.build_number,
                                                                                                              upload_bit),
                 options.workspace)

    call_command("%sbin/epydoc --html --graph all %s" % (venvDir, options.package),
                 options.workspace)

    logging.info("Complete")

if __name__ == "__main__":
    main()

Cuando se trata de implementar cosas, puedes hacer algo como:

pip -E /location/of/my/venv/ install my_package==X.Y.Z --extra-index http://my_repo

Y luego las personas pueden desarrollar cosas usando:

pip -E /location/of/my/venv/ install -e ./ --extra-index http://my_repo

Esto supone que tienes una estructura repo por paquete con un setup.py y dependencias todas configuradas, entonces puedes ver el trunk y ejecutar esto en él.

Espero que ésto ayude a alguien.

------actualizar---------

He añadido epydoc que encaja muy bien con Hudson. Simplemente agrega javadoc a tu configuración con la carpeta html

Tenga en cuenta que pip no es compatible con la bandera -E correctamente en estos días, por lo que debe crear su venv por separado

Answer 12

Verifique rultor.com . Como se explica en este artículo , utiliza Docker para cada compilación. Gracias a eso, puedes configurar lo que quieras dentro de tu imagen de Docker, incluido Python.

Answer 13

otro: Shining Panda es una herramienta alojada para python

Answer 14

binstar de binstar ahora puede activar compilaciones desde github y puede compilar para linux, osx y windows (32/64). Lo bueno es que realmente te permite acoplar de cerca la distribución y la integración continua. Eso es cruzar las "t" y salpicar los "yoes" de la integración. El sitio, el flujo de trabajo y las herramientas están realmente pulidos y AFAIK conda es la forma más robusta y pitónica de distribuir módulos de python complejos, donde debe envolver y distribuir las bibliotecas de C / C ++ / Fotran.