Jak oznaczyć kompilację jako niestabilną w Jenkinsie podczas uruchamiania skryptów powłoki

W projekcie, nad którym pracuję, używamy skryptów powłoki do wykonywania różnych zadań. Niektóre z nich to skrypty sh / bash, które uruchamiają rsync, a inne to skrypty PHP. Jeden ze skryptów PHP uruchamia testy integracji, które generują dane w formacie XML JUnit, raporty pokrycia kodu i tym podobne.

Jenkins jest w stanie oznaczyć zadania jako zakończone sukcesem / niepowodzeniem na podstawie statusu wyjścia . W PHP skrypt kończy pracę z wartością 1, jeśli wykryje, że testy zakończyły się niepowodzeniem podczas wykonywania. Pozostałe skrypty powłoki uruchamiają polecenia i używają kodów zakończenia z nich, aby oznaczyć kompilację jako nieudaną.

// :: End of PHP script:
// If any tests have failed, fail the build
if ($build_error) exit(1);

W terminologii Jenkinsa niestabilna kompilacja jest definiowana jako:

Kompilacja jest niestabilna, jeśli została pomyślnie utworzona, a co najmniej jeden wydawca zgłasza, że ​​jest niestabilna. Na przykład, jeśli wydawca JUnit jest skonfigurowany i test zakończy się niepowodzeniem, kompilacja zostanie oznaczona jako niestabilna.

Jak mogę sprawić, by Jenkins oznaczał kompilację jako niestabilną, a nie tylko sukces / niepowodzenie, podczas uruchamiania skryptów powłoki?

Użyj wtyczki Text-Finder .

Zamiast wychodzić ze statusem 1 (co spowodowałoby niepowodzenie kompilacji), wykonaj:

if ($build_error) print("TESTS FAILED!");

Następnie w czynnościach post-kompilacyjnych włącz wyszukiwarkę tekstu, ustaw wyrażenie regularne tak, aby pasowało do wydrukowanej wiadomości ( TESTS FAILED!) i zaznacz pole wyboru „Niestabilne, jeśli znaleziono” pod tym wpisem.

Nowoczesne wersje Jenkinsa (od 2.26, październik 2016) rozwiązały ten problem: to tylko zaawansowana opcja dla kroku budowania powłoki Wykonaj!

Możesz po prostu wybrać i ustawić dowolną wartość wyjścia; jeśli pasuje, kompilacja będzie niestabilna. Po prostu wybierz wartość, która prawdopodobnie nie zostanie uruchomiona przez prawdziwy proces w twojej kompilacji.

Można to zrobić bez drukowania magicznych ciągów i używania TextFindera. Oto kilka informacji na ten temat.

Zasadniczo potrzebujesz pliku .jar z http: // yourserver.com / cli dostępnego w skryptach powłoki, a następnie możesz użyć następującego polecenia, aby oznaczyć kompilację jako niestabilną:

java -jar jenkins-cli.jar set-build-result unstable

Aby oznaczyć kompilację jako niestabilną po błędzie, możesz użyć:

failing_cmd cmd_args || java -jar jenkins-cli.jar set-build-result unstable

Problem polega na tym, że plik jenkins-cli.jar musi być dostępny ze skryptu powłoki. Możesz umieścić go w łatwo dostępnej ścieżce lub pobrać za pomocą skryptu powłoki zadania:

wget ${JENKINS_URL}jnlpJars/jenkins-cli.jar

Powinieneś użyć Jenkinsfile, aby opakować skrypt kompilacji i po prostu oznaczyć bieżącą kompilację jako NIESTABILNĄ przy użyciu currentBuild.result = "UNSTABLE".

   etap {
      status = / * twoje polecenie kompilacji jest tutaj * /
      if (status === "OZNACZ-JAKO NIESTABILNE") {
        currentBuild.result = "NIESTABILNE"
      }
   }

Powinieneś także umieć używać groovy i robić to, co zrobił Textfinder

oznaczanie kompilacji jako niestabilnej za pomocą groovy plugin post-build

if(manager.logContains("Could not login to FTP server")) {
    manager.addWarningBadge("FTP Login Failure")
    manager.createSummary("warning.gif").appendText("<h1>Failed to login to remote FTP Server!</h1>", false, false, false, "red")
    manager.buildUnstable()
}

Zobacz także wtyczkę Groovy Postbuild

W moim skrypcie pracy mam następujące oświadczenia (to zadanie działa tylko na serwerze głównym Jenkins):

# This is the condition test I use to set the build status as UNSTABLE
if [ ${PERCENTAGE} -gt 80 -a ${PERCENTAGE} -lt 90 ]; then
  echo WARNING: disc usage percentage above 80%

  # Download the Jenkins CLI JAR:
  curl -o jenkins-cli.jar ${JENKINS_URL}/jnlpJars/jenkins-cli.jar

  # Set build status to unstable
  java -jar jenkins-cli.jar -s ${JENKINS_URL}/ set-build-result unstable

fi

Możesz zobaczyć to i wiele więcej informacji na temat ustawiania statusu kompilacji na wiki Jenkins: https://wiki.jenkins-ci.org/display/JENKINS/Jenkins+CLI

1. Skonfiguruj kompilację PHP do tworzenia raportu junit XML

   <phpunit bootstrap="tests/bootstrap.php" colors="true" >
      <logging>
          <log type="junit" target="build/junit.xml" 
              logIncompleteSkipped="false" title="Test Results"/>
      </logging>
   
      ....
   
    </phpunit>
   

2. Zakończ kompilację skryptu ze statusem 0

   ...
   exit 0;
   

3. Dodaj akcję po kompilacji Opublikuj raport wyników testu JUnit dla plików XML raportu z testu. Ta wtyczka zmieni kompilację stabilną na niestabilną, gdy test zakończy się niepowodzeniem.

   **/build/junit.xml
   

4. Dodaj wtyczkę Jenkins Text Finder ze skanowaniem wyników konsoli i niezaznaczonymi opcjami. Ta wtyczka nie działa w całej kompilacji z powodu błędu krytycznego.

   PHP Fatal error:
   

Uważam, że najbardziej elastycznym sposobem na to jest odczytanie pliku we wtyczce groovy post build.

import hudson.FilePath
import java.io.InputStream

def build = Thread.currentThread().executable

String unstable = null
if(build.workspace.isRemote()) {
    channel = build.workspace.channel;
    fp = new FilePath(channel, build.workspace.toString() + "/build.properties")
    InputStream is = fp.read()
    unstable = is.text.trim()
} else {
    fp = new FilePath(new File(build.workspace.toString() + "/build.properties"))
    InputStream is = fp.read()
    unstable = is.text.trim()
}

manager.listener.logger.println("Build status file: " + unstable)
if (unstable.equalsIgnoreCase('true')) {
    manager.listener.logger.println('setting build to unstable')
    manager.buildUnstable()
}

Jeśli zawartość pliku ma wartość „prawda”, kompilacja zostanie ustawiona na niestabilną. Będzie to działać na lokalnym urządzeniu głównym i na wszystkich urządzeniach podrzędnych, na których uruchamiasz zadanie, oraz na wszelkiego rodzaju skryptach, które mogą zapisywać na dysku.

TextFinder jest dobry tylko wtedy, gdy status zadania nie został zmieniony z SUCCESS na FAILED lub ABORTED. W takich przypadkach użyj groovy skryptu w kroku PostBuild:

errpattern = ~/TEXT-TO-LOOK-FOR-IN-JENKINS-BUILD-OUTPUT.*/;
manager.build.logFile.eachLine{ line ->
    errmatcher=errpattern.matcher(line)
    if (errmatcher.find()) {
        manager.build.@result = hudson.model.Result.NEW-STATUS-TO-SET
    }
 }

Zobacz więcej szczegółów w poście, który o tym napisałem: http://www.tikalk.com/devops/JenkinsJobStatusChange/

Powielam moją odpowiedź tutaj, ponieważ spędziłem trochę czasu na szukaniu tego:

Jest to teraz możliwe w nowszych wersjach Jenkinsa, możesz zrobić coś takiego:

#!/usr/bin/env groovy

properties([
  parameters([string(name: 'foo', defaultValue: 'bar', description: 'Fails job if not bar (unstable if bar)')]),
])


stage('Stage 1') {
  node('parent'){
    def ret = sh(
      returnStatus: true, // This is the key bit!
      script: '''if [ "$foo" = bar ]; then exit 2; else exit 1; fi'''
    )
    // ret can be any number/range, does not have to be 2.
    if (ret == 2) {
      currentBuild.result = 'UNSTABLE'
    } else if (ret != 0) {
      currentBuild.result = 'FAILURE'
      // If you do not manually error the status will be set to "failed", but the
      // pipeline will still run the next stage.
      error("Stage 1 failed with exit code ${ret}")
    }
  }
}

Generator składni potoku pokazuje to na karcie Zaawansowane:

Pomyślałem, że opublikuję kolejną odpowiedź dla osób, które mogą szukać czegoś podobnego.

W naszej pracy kompilacji mamy przypadki, w których chcielibyśmy, aby kompilacja była kontynuowana, ale została oznaczona jako niestabilna. W naszym przypadku dotyczy to numerów wersji.

Tak więc chciałem ustawić warunek dla kompilacji i ustawić kompilację jako niestabilną, jeśli ten warunek zostanie spełniony.

Użyłem opcji Krok warunkowy (pojedynczy) jako krok kompilacji.

Następnie użyłem skryptu Execute system Groovy jako kroku kompilacji, który zostanie uruchomiony, gdy ten warunek zostanie spełniony.

Użyłem Groovy Command i ustawiłem następujący skrypt

import hudson.model.*

def build = Thread.currentThread().executable
build.@result = hudson.model.Result.UNSTABLE

return

Wydaje się, że działa całkiem nieźle.

Natknąłem się tutaj na rozwiązanie

http://tech.akom.net/archives/112-Marking-Jenkins-build-UNSTABLE-from-environment-inject-groovy-script.html

Jako lżejszą alternatywę dla istniejących odpowiedzi, możesz ustawić wynik kompilacji za pomocą prostego HTTP POST, aby uzyskać dostęp do interfejsu API REST konsoli skryptów Groovy :

    curl -X POST \
     --silent \
     --user "$YOUR_CREDENTIALS" \
     --data-urlencode "script=Jenkins.instance.getItemByFullName( '$JOB_NAME' ).getBuildByNumber( $BUILD_NUMBER ).setResult( hudson.model.Result.UNSTABLE )" $JENKINS_URL/scriptText

Zalety:

• nie ma potrzeby pobierania i uruchamiania ogromnego pliku jar
• brak możliwości ustawiania i czytania niektórych stanów globalnych (tekst konsoli, pliki w obszarze roboczym)
• nie są wymagane żadne wtyczki (poza Groovym)
• nie ma potrzeby konfigurowania dodatkowego kroku kompilacji, który jest zbędny w przypadkach PASSED lub FAILURE.

W przypadku tego rozwiązania środowisko musi spełniać następujące warunki:

• Dostęp do interfejsu API Jenkins REST można uzyskać z poziomu slave
• Slave musi mieć dostęp do poświadczeń, które umożliwiają dostęp do interfejsu API REST skryptów Jenkins Groovy.

Jednym z łatwych sposobów ustawienia kompilacji jako niestabilnej jest użycie bloku „execute shell”, uruchomienie exit 13

Możesz po prostu wywołać „exit 1”, a kompilacja zakończy się niepowodzeniem w tym momencie i nie będzie kontynuowana. Skończyło się na utworzeniu funkcji przejściowej, która obsługuje to za mnie, i wzywam safemake zamiast tworzyć:

function safemake {
  make "$@"
  if [ "$?" -ne 0 ]; then
    echo "ERROR: BUILD FAILED"
    exit 1
  else
    echo "BUILD SUCCEEDED"
  fi
}