"सुंदर" पायथन के लिए निरंतर एकीकरण

Question

यह एक छोटा सा है .. व्यर्थ सवाल है, लेकिन BuildBot के उत्पादन को देखने के लिए विशेष रूप से अच्छा नहीं है ..

उदाहरण के लिए, की तुलना में ..

• phpUnderControl
• जेनकींस
  • हडसन
• CruiseControl.rb

.. और, बिल्डबॉट बल्कि दिखता है .. पुरातन

मैं वर्तमान में हडसन के साथ खेल रहा हूं, लेकिन यह बहुत जावा-केंद्रित है (हालांकि इस गाइड के साथ , मुझे बिल्डबॉट की तुलना में सेटअप करना आसान लगा, और अधिक जानकारी का उत्पादन किया)

मूल रूप से: क्या अजगर के उद्देश्य से कोई निरंतर एकीकरण प्रणाली है, जो बहुत सारे चमकदार रेखांकन और पसंद का उत्पादन करती है?

---

अद्यतन: इस समय के बाद से जेनकिन्स परियोजना ने हडसन को पैकेज के सामुदायिक संस्करण के रूप में बदल दिया है। मूल लेखक इस परियोजना में भी चले गए हैं। जेनकिंस अब उबंटू / डेबियन, रेडहैट / फेडोरा / सेंटोस और अन्य पर एक मानक पैकेज है। निम्नलिखित अद्यतन अभी भी अनिवार्य रूप से सही है। जेनकिंस के साथ ऐसा करने का शुरुआती बिंदु अलग है।

अपडेट: कुछ विकल्पों को आजमाने के बाद, मुझे लगता है कि मैं हडसन के साथ रहूंगा। ईमानदारी अच्छी और सरल थी, लेकिन काफी सीमित थी। मुझे लगता है कि बिल्डबोट कई बिल्ड- स्लेव रखने के लिए बेहतर है, बजाय एक मशीन पर चलने वाली हर चीज की तरह मैं इसका उपयोग कर रहा था।

पायथन परियोजना के लिए हडसन को स्थापित करना बहुत सरल था:

• डाउनलोड हडसन http://hudson-ci.org/ से
• इसे लेकर चलें java -jar hudson.war
• के डिफ़ॉल्ट पते पर वेब इंटरफ़ेस खोलें http://localhost:8080
• हडसन, प्लगइन्स को प्रबंधित करने के लिए जाएं, "अपडेट" या समान पर क्लिक करें
• Git प्लगइन स्थापित करें (मुझे gitहडसन वैश्विक प्राथमिकताओं में रास्ता तय करना था )
• एक नई परियोजना बनाएं, रिपॉजिटरी, एससीएम मतदान अंतराल और इतने पर दर्ज करें
• स्थापित nosetestsके माध्यम से easy_installकरता है, तो यह पहले से ही नहीं है
• एक बिल्ड चरण में, जोड़ें nosetests --with-xunit --verbose
• "प्रकाशित JUnit परीक्षा परिणाम रिपोर्ट" की जाँच करें और "टेस्ट रिपोर्ट XMLs" सेट करें **/nosetests.xml

बस इतना ही चाहिए। आप ईमेल सूचनाएँ सेटअप कर सकते हैं, और प्लगइन्स देखने लायक हैं। कुछ मैं वर्तमान में पायथन परियोजनाओं के लिए उपयोग कर रहा हूं:

• कोड की लाइनों को गिनने के लिए SLOCCount प्लगइन (और इसे ग्राफ करें!) - आपको अलग से स्लोकाउंट स्थापित करने की आवश्यकता है
• PyLint आउटपुट को पार्स करने के लिए उल्लंघन (आप चेतावनी थ्रेसहोल्ड सेटअप कर सकते हैं, प्रत्येक बिल्ड पर उल्लंघन की संख्या को ग्राफ कर सकते हैं)
• कोबर्तुरा कवरेज थ्रू आउटपुट को पार्स कर सकता है। Nosetest आपके परीक्षण चलाते समय कवरेज इकट्ठा कर सकता है, nosetests --with-coverage(यह आउटपुट लिखता है **/coverage.xml)

Comments

महान प्रश्न, मैं अभी ऐसी ही चीजों को देख रहा हूं। यदि आप एक मार्ग पर जाते हैं, तो क्या आप अपना अनुभव हममें से बाकी लोगों के साथ साझा कर सकते हैं?

— आंद्रे

पता नहीं है कि क्या यह तब उपलब्ध था जब आपने यह लिखा था: हडसन के लिए चक नॉरिस प्लगइन का उपयोग करें ताकि आपके सामान पर नियंत्रण बढ़ाया जा सके!

— जोहान्स चरारा

2011-2015 के लिए अपडेट : हडसन पर विचार करने वालों को जेनकिन्स का उपयोग करना चाहिए , हडसन परियोजना का खुला स्रोत निरंतरता (हडसन अब ओरेकल द्वारा नियंत्रित किया जाता है )

— विचारक

Answer 1

आप नाक और Xunit आउटपुट प्लगइन की जाँच कर सकते हैं । आप इसे अपने यूनिट परीक्षण और इस कमांड के साथ कवरेज जांच कर सकते हैं:

nosetests --with-xunit --enable-cover

यदि आप जेनकिंस मार्ग पर जाना चाहते हैं, तो आप मददगार होंगे, या यदि आप किसी अन्य CI सर्वर का उपयोग करना चाहते हैं जिसमें JUnit परीक्षण रिपोर्टिंग का समर्थन है।

इसी तरह आप जेनकिंस के लिए उल्लंघन प्लगइन का उपयोग करके पाइलिंट के आउटपुट को कैप्चर कर सकते हैं

Comments

नाक में अब xunit प्लगइन डिफ़ॉल्ट रूप से शामिल है -nosetests --with-xunit

— dbr

तो फिर कैसे एक Pylint से ऑडिटिंग चलाता है? जब मुझे nosetests --with-xunit --enable-auditमिलता हैnosetests: error: no such option: --enable-audit

— एडम पार्किन

आधुनिकीकरण का उत्तर, NoseXUnit सामान अब बनाया गया है और दुर्भाग्यपूर्ण-जब-डाउन-डाउन किया --with-nosexunitगया है --with-xunit।

— dbr

Answer 2

पता नहीं कि यह क्या करेगा: बिटकॉइन उन लोगों द्वारा किया जाता है जो Trac लिखते हैं और Trac के साथ एकीकृत होते हैं। Apache Gump , Apache द्वारा प्रयुक्त CI उपकरण है। यह पायथन में लिखा गया है।

Answer 3

हमें अपने सीआई सर्वर के रूप में टीमकिट के साथ बड़ी सफलता मिली है और हमारे परीक्षण धावक के रूप में नाक का उपयोग किया गया है। नोसिटेट के लिए टीमसिटी प्लगइन आपको असफल परीक्षा के लिए गिनती पास / असफल, पठनीय प्रदर्शन (जो कि ई-मेल किया जा सकता है) देता है। जब आप स्टैक चला रहे हों तब आप परीक्षण विफलताओं का विवरण भी देख सकते हैं।

यदि बेशक कई मशीनों पर चलने जैसी चीजों का समर्थन करता है, और बिल्डबॉट की तुलना में इसे सेटअप करना और बनाए रखना बहुत सरल है।

Answer 4

बिल्डबोट के झरने के पृष्ठ को काफी पहले से चित्रित किया जा सकता है। यहाँ एक अच्छा उदाहरण है http://build.chromium.org/buildbot/waterfall/waterfall

Answer 5

एटलसियन का बांस भी निश्चित रूप से जांचने लायक है। संपूर्ण एटलसियन स्‍वीट (JIRA, Confluence, FishEye, आदि) बहुत मधुर है।

Answer 6

मुझे लगता है कि यह धागा काफी पुराना है, लेकिन यहाँ पर इसे हडसन के साथ लिया गया है:

मैंने पाइप के साथ जाने का फैसला किया और रेपो (काम करने के लिए दर्दनाक लेकिन अच्छा दिखने वाला एगबास्केट) स्थापित किया, जो हडसन ऑटो एक सफल परीक्षण के साथ अपलोड करता है। यहाँ एक हडसन कॉन्फिगर स्क्रिप्ट पर अमल करने के लिए मेरी रफ एंड रेडी स्क्रिप्ट है जैसे: /var/lib/hudson/venv/main/bin/hudson_script.py -w $ WORKSPACE -p my.package -v $ BUILD_NUMBER, बस डाल ** और विन्यास बिट्स, pylint.txt और nosetests.xml विन्यास बिट्स में:

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

जब सामान की तैनाती की बात आती है तो आप कुछ ऐसा कर सकते हैं:

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

और फिर लोग उपयोग करके सामान विकसित कर सकते हैं:

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

यह सामान मानता है कि आपके पास प्रति सेटअप के साथ एक रेपो संरचना है और सभी सेट अप निर्भरताएं हैं तो आप केवल ट्रंक की जांच कर सकते हैं और इस सामान को उस पर चला सकते हैं।

मुझे उम्मीद है कि इससे किसी को मदद मिलेगी।

------अपडेट करें---------

मैंने एपिडॉक जोड़ा है जो वास्तव में हडसन के साथ फिट बैठता है। Html फोल्डर के साथ अपने कॉन्फिगर में बस javadoc जोड़ें

ध्यान दें कि पाइप इन दिनों -E ध्वज का ठीक से समर्थन नहीं करता है, इसलिए आपको अलग से अपना venv बनाना होगा

Comments

यह उत्तर बहुत उपयोगी है और पायथन सीआई के आंतरिक के संबंध में बहुत सारे विवरण हैं, कुछ जो आपको जेनकिंस या जो कुछ भी मुफ्त में नहीं मिलेगा। धन्यवाद!

— maksimov

Answer 7

एक अन्य: शाइनिंग पांडा अजगर के लिए एक होस्ट किया गया उपकरण है

Answer 8

यदि आप होस्ट किए गए सीआई समाधान पर विचार कर रहे हैं, और ओपन सोर्स कर रहे हैं, तो आपको ट्रैविस सीआई को भी देखना चाहिए - इसका गीथहब के साथ बहुत अच्छा एकीकरण है। जबकि यह एक रूबी उपकरण के रूप में शुरू हुआ, उन्होंने कुछ समय पहले पायथन समर्थन जोड़ा है ।

Answer 9

सिग्नल एक और विकल्प है। आप इसके बारे में अधिक जान सकते हैं और यहां एक वीडियो भी देख सकते हैं ।

Answer 10

मैं CircleCi पर विचार करूंगा - इसमें महान पायथन समर्थन है, और बहुत सुंदर आउटपुट है।

Answer 11

सातत्य के बिस्टार अब जीथब से बिल्ड को ट्रिगर करने में सक्षम है और लिनक्स, ऑक्स और विंडोज़ (32/64) के लिए संकलन कर सकता है। साफ बात यह है कि यह वास्तव में आपको जोड़े के वितरण और निरंतर एकीकरण की अनुमति देता है। वह टी पार कर रहा है और एकीकरण के I को डॉट कर रहा है। साइट, वर्कफ़्लो और टूल वास्तव में पॉलिश किए जाते हैं और AFAIK कोंडा जटिल पायथन मॉड्यूल को वितरित करने का सबसे मजबूत और पायथोनिक तरीका है, जहां आपको C / C ++ / Fotran पुस्तकालयों को लपेटने और वितरित करने की आवश्यकता होती है।

Answer 12

हमने काटे का काफी इस्तेमाल किया है। यह सुंदर है और Trac के साथ अच्छी तरह से एकीकृत है, लेकिन यदि आपके पास कोई गैर-मानक वर्कफ़्लो है, तो इसे अनुकूलित करने के लिए बट में दर्द होता है। इसके अलावा वहाँ नहीं कर रहे हैं बस के रूप में कई प्लगइन्स के रूप में अधिक लोकप्रिय उपकरण के लिए कर रहे हैं। वर्तमान में हम एक प्रतिस्थापन के रूप में हडसन का मूल्यांकन कर रहे हैं।

Answer 13

Rultor.com चेक करें । जैसा कि यह लेख बताता है, यह हर बिल्ड के लिए डॉकर का उपयोग करता है। इसके लिए धन्यवाद, आप पाइथन सहित अपनी डॉकर छवि के अंदर जो कुछ भी चाहें उसे कॉन्फ़िगर कर सकते हैं।

Answer 14

थोड़ा अस्वीकरण, मुझे वास्तव में इस तरह के समाधान के लिए एक क्लाइंट का निर्माण करना था जो कि स्वचालित रूप से परीक्षण करना चाहता था और एक गिट पुश पर किसी भी कोड को तैनात करने और जीआईटी नोट्स के माध्यम से समस्या टिकट का प्रबंधन करने के लिए। इससे AIMS प्रोजेक्ट पर भी मेरा काम चल रहा है ।

एक बड़ी आसानी से सेटअप सकता है एक नंगे नोड प्रणाली निर्माण उपयोगकर्ता है और के माध्यम से अपने निर्माण का प्रबंधन है कि make(1), expect(1), crontab(1)/ systemd.unit(5), और incrontab(1)। एक कदम आगे भी जा सकता है और ग्रिडफिश / एनएफएस फ़ाइल स्टोर के साथ वितरित बिल्ड के लिए ansible और अजवाइन का उपयोग कर सकता है।

हालांकि, मैं किसी ग्रेबर्ड यूनिक्स लड़के या प्रिंसिपल स्तर के इंजीनियर / आर्किटेक्ट के अलावा किसी से भी यह उम्मीद नहीं करूंगा कि यह वास्तव में आगे बढ़ेगा। बस एक अच्छा विचार और संभावित सीखने के अनुभव के लिए बनाता है क्योंकि एक बिल्ड सर्वर एक स्वचालित फैशन में स्क्रिप्टेड कार्यों को मनमाने ढंग से निष्पादित करने के तरीके से ज्यादा कुछ नहीं है।