„Pretty“ Continuous Integration für Python

https://stackoverflow.com/questions/225598

03-07-2019
|

Frage

Dies ist eine etwas .. vergeblich Frage, aber BuildBot des Ausgang ist nicht besonders schön anzusehen ..

Zum Beispiel im Vergleich zu ..

.. und andere, BuildBot sieht eher .. archaisch

Ich spiele zur Zeit mit Hudson, aber es ist sehr Java-centric (wenn auch mit dieser Leitfaden , fand ich es einfacher aufzusetzen als BuildBot und weitere Informationen erzeugt)

Grundsätzlich gilt: ist es Continuous Integration Systeme in Python richtet, die viele glänzende Grafiken und die Gleichen erzeugen

Update: Seit dieser Zeit ist das Jenkins Projekt Hudson als Community-Version des Pakets ersetzt hat. Die ursprünglichen Autoren haben auch für dieses Projekt bewegen. Jenkins ist jetzt ein Standard-Paket auf Ubuntu / Debian, RedHat / Fedora / CentOS und andere. Das folgende Update ist nach wie vor im Wesentlichen richtig. Der Ausgangspunkt, dies zu tun mit Jenkins unterschiedlich ist.

Update: Nach ein paar Alternativen versuchen, ich glaube, ich mit Hudson bleiben werde. Integrität war schön und einfach, aber sehr begrenzt. Ich denke, Buildbot ist besser geeignet, zahlreiche build-Sklaven zu haben, anstatt alles auf einer einzigen Maschine laufen wie ich war mit es.

Einstellung Hudson für ein Python-Projekt war ziemlich einfach:

Download Hudson von http://hudson-ci.org/
Führen Sie es mit java -jar hudson.war
Öffnen Sie die Web-Schnittstelle auf der Standardadresse http://localhost:8080
Gehe zu verwalten Hudson, Plugins, klicken Sie auf "Update" oder ähnliche
Installieren Sie die Git-Plugin (ich hatte den git Weg in der Hudson globalen Einstellungen festlegen)
Erstellen Sie ein neues Projekt, geben Sie das Repository, SCM Abfrageintervalle usw.
Installieren nosetests über easy_install wenn es nicht bereits ist
Im einem Build Schritt fügt nosetests --with-xunit --verbose
Überprüfen "JUnit Testergebnis Bericht Publish" und "Prüfbericht XMLs" **/nosetests.xml

Das ist alles, was erforderlich ist. Sie können Setup E-Mail-Benachrichtigungen und Plugins einen Blick wert sind. Ein paar ich bin derzeit für Python-Projekte:

SLOCCount Plugin Codezeilen zu zählen (und grafisch darstellen es! ) - müssen Sie sloccount separat
Verletzungen die PyLint Ausgabe zu analysieren (Sie können Setup Warnschwellen, Graph die Zahl der Verletzungen über jeden Build)
Cobertura können die coverage.py Ausgabe analysieren. Nosetest kann Abdeckung sammeln, während die Tests ausgeführt wird, unter Verwendung von nosetests --with-coverage (dies die Ausgabe **/coverage.xml schreibt)

Lösung

Sie möchten vielleicht Nose href="http://somethingaboutorange.com/mrl/projects/nose/" überprüfen und die xUnit Ausgabe-Plugin . Sie können es Ihre Unit-Tests und Berichterstattung Kontrollen mit diesem Befehl ausgeführt haben:

nosetests --with-xunit --enable-cover

Das wird hilfreich sein, wenn Sie den Jenkins Weg gehen wollen, oder wenn Sie einen anderen CI-Server verwenden mögen, die Unterstützung für JUnit-Testberichterstattung hat.

Ebenso können Sie die Ausgabe von Pylint erfassen die Verletzungen Plugin für Jenkins mit

Andere Tipps

Sie wissen nicht, ob es tun würde: Gebissen von den Jungs gemacht, die Trac schreiben und ist integriert mit Trac. Apache Gump ist das CI-Tool von Apache verwendet. Es ist in Python geschrieben.

Wir haben großen Erfolg gehabt mit Teamcity als unseren CI-Server und mit Nase, als unser Test-Runner . Teamcity-Plugin für nosetests bestanden / nicht bestanden, gut lesbare Anzeige für fehlgeschlagene Test gibt rechnen (das kann seine E-Mail). Sie können sogar Details der Testfehler sehen, während Sie läuft stapeln.

Wenn natürlich unterstützt Dinge wie auf mehreren Computern ausgeführt wird, und es ist viel einfacher zu installieren und warten als buildbot.

Buildbot der Wasserfall Seite erheblich prettified sein. Hier ist ein schönes Beispiel http://build.chromium.org/buildbot/waterfall/waterfall

Bamboo auch auf jeden Fall einen Besuch wert ist out. Die gesamte Atlassian Suite (JIRA, Confluence, FishEye, usw.) ist ziemlich süß.

Ich denke, dieser Thread ist ziemlich alt, aber hier ist mein nehmen auf sie mit hudson:

habe ich beschlossen, mit pip zu gehen und einen Repo einrichten (die schmerzhaften, aber gut aussehenden eggbasket zum Laufen zu bringen), das hudson auto-Uploads mit erfolgreichen Tests. Hier ist meine notdürftig Skript für die Verwendung mit einem hudson Config ausführen Skript wie: /var/lib/hudson/venv/main/bin/hudson_script.py -w $ ARBEITSBEREICH -p my.package -v $ BUILD_NUMBER, nur setzen in ** / coverage.xml, pylint.txt und nosetests.xml in dem Config-Bits:

#!/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()

Wenn es Sachen Bereitstellung kommt, kann man so etwas tun:

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

Und dann können die Menschen entwickeln Sachen mit:

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

Dieses Zeug vorausgesetzt, dass Sie eine Repo-Struktur pro Paket mit einem setup.py haben und Abhängigkeiten alle einrichten, dann können Sie nur den Kofferraum heraus überprüfen und dieses Material auf ihn laufen.

Ich hoffe, das hilft jemand aus.

------ Update ---------

Ich habe epydoc hinzugefügt, die mit hudson in wirklich gut passt. Fügen Sie einfach javadoc auf Ihre Konfiguration mit dem HTML-Ordner

, dass pip Hinweis nicht die -E-Flag richtig in diesen Tagen unterstützen, so dass Sie Ihre Venv separat erstellen

ein anderes: Leuchtender Panda ist eine gehostete Tool für Python

Wenn Sie erwägen, gehostet CI-Lösung und Open Source zu tun, sollten Sie schauen in Travis CI als gut - es hat sehr schöne Integration mit GitHub. Während es als Ruby-Tool gestartet, haben sie Python Unterstützung vor eine Weile hinzu.

Signal ist eine weitere Option. Sie können mehr darüber wissen und ein Video auch

Ich würde CircleCi -. Es große Python-Unterstützung hat, und sehr hübsch Ausgabe

Kontinuum binstar jetzt in der Lage, von Github baut auslösen und kompilieren können Linux, OS X und Fenster (32/64). die nette Sache ist, dass es Ihnen erlaubt, wirklich eng Paar Verteilung und kontinuierliche Integration. Das ist die Kreuzung t und Punktierung der I. von Integration. Die Website, Workflow und Werkzeuge sind wirklich poliert und AFAIK Conda ist die robusteste und pythonic Art und Weise komplexe Python-Module zu verteilen, wo Sie wickeln müssen und verteilt C / C ++ / Fotran Bibliotheken.

Wir haben verwendet ziemlich viel gebissen. Es ist schön und integriert sich gut mit Trac, aber es ist ein Schmerz in den Hintern zu gestalten, wenn Sie eine Nicht-Standard-Workflow haben. Auch gibt es einfach nicht so viele Plugins, da es für die immer beliebter Werkzeuge sind. Derzeit Hudson als Ersatz wir evaluieren.

Überprüfen Sie rultor.com . Wie diesem Artikel erklärt, verwendet es Docker für jeden Build . Dank dem können Sie einstellen, was auch immer Sie in Ihrem Docker Bild, wie zum Beispeil Python.

Little wichtiger Hinweis, ich hatte tatsächlich eine Lösung wie diese für einen Kunden zu erstellen, die eine Möglichkeit zum automatischen Testen und Bereitstellen von wollte jeder Code auf einem git push und verwaltet die Ausgabe Tickets über git Noten . Das gilt auch für meine Arbeit auf der Projekt AIMS.

Man könnte einfach nur das Einrichten eines nackten Knoten-System, das einen Build Benutzer hat und verwalten ihre Build durch make(1), expect(1), crontab(1) / systemd.unit(5) und incrontab(1). Man könnte sogar noch einen Schritt weiter gehen und verwendet ansible und Sellerie für verteilen baut mit einer gridfs / nfs-Datei zu speichern.

Auch wenn, würde ich nicht jemand erwarten, dass andere als ein Graybeard UNIX Typ oder Prinzip Ebene Ingenieur / Architekten tatsächlich so weit gehen. Nur macht für eine nette Idee und potenzielle Lernerfahrung, da ein Build-Server nicht mehr als ein Weg ist, um willkürlich scripted Aufgaben automatisiert auszuführen.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow