shell - resueltos - scripts bash ejemplos

Cómo marcar una compilación inestable en Jenkins al ejecutar scripts de shell

Question

En un proyecto en el que estoy trabajando estamos usando scripts de shell para ejecutar diferentes tareas. Algunos scripts son SH / Bash que ejecuta Rsync y algunos son scripts PHP. Uno de los scripts PHP está ejecutando algunas pruebas de integración que dan salida a JUnit XML, informes de cobertura de código y similares.

Jenkins puede marcar los trabajos como estado de salida basado en éxito / error . En PHP, el script sale con 1 si ha detectado que las pruebas fallaron durante la ejecución. Los otros scripts de shell ejecutan comandos y utilizan los códigos de salida de aquellos para marcar una compilación como fallida.

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

En la terminología de Jenkins, una construcción inestable se define como

Una construcción es inestable si se construyó con éxito y uno o más editores la declaran inestable. Por ejemplo, si el publicador JUnit está configurado y una prueba falla, la construcción se marcará como inestable.

¿Cómo puedo hacer que Jenkins marque una compilación como inestable en lugar de solo éxito / error al ejecutar scripts de shell?

Answer 1

1. Configure PHP build para producir xml junit report

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

2. Terminar el script de compilación con estado 0

   ...
   exit 0;

3. Agregar acción posterior a la publicación Publicar el informe de resultados de la prueba JUnit para XML de informes de prueba. Este complemento cambiará la creación estable a inestable cuando fallan las pruebas.

   **/build/junit.xml

4. Agregue el complemento Jenkins Text Finder con escaneo de salida de consola y opciones sin marcar. Este complemento no funciona correctamente en caso de error grave.

   PHP Fatal error:

Answer 2

Como una alternativa más ligera a las respuestas existentes, puede establecer el resultado de la compilación con un HTTP POST simple para acceder a la API de REST de la consola de script de 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

Ventajas:

• no es necesario descargar y ejecutar un gran archivo jar
• no hay kludges para configurar y leer algún estado global (texto de la consola, archivos en el área de trabajo)
• no se requieren complementos (además de Groovy)
• no es necesario configurar un paso de compilación adicional que es superfluo en los casos APROBADO o FALLO.

Para esta solución, su entorno debe cumplir estas condiciones:

• Se puede acceder a Jenkins REST API desde el esclavo
• El esclavo debe tener acceso a credenciales que le permitan acceder a la API REST de la secuencia de comandos Jenkins Groovy.

Answer 3

Debería usar Jenkinsfile para envolver su script de compilación y simplemente marcar la compilación actual como INESTABLE utilizando currentBuild.result = "UNSTABLE" .

stage { status = /* your build command goes here */ if (status === "MARK-AS-UNSTABLE") { currentBuild.result = "UNSTABLE" } }

Answer 4

El TextFinder es bueno solo si el estado del trabajo no ha cambiado de SUCCESS a FAILED o ABORTED. Para tales casos, use una secuencia de comandos groovy en el paso 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
    }
 }

Ver más detalles en una publicación que escribí al respecto: http://www.tikalk.com/devops/JenkinsJobStatusChange/

Answer 5

En mi script de trabajo, tengo las siguientes afirmaciones (este trabajo solo se ejecuta en el maestro de 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

Puedes ver esto y mucha más información sobre cómo configurar estados de compilación en la wiki de Jenkins: Here''s

Answer 6

La forma más flexible de hacerlo es leyendo un archivo en el plugin 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()
}

Si el contenido del archivo es ''verdadero'', la compilación se establecerá en inestable. Esto funcionará en el maestro local y en cualquier esclavo en el que ejecute el trabajo, y para cualquier tipo de scripts que puedan escribir en el disco.

Answer 7

Las versiones modernas de Jenkins resolvieron esto: ¡es solo una opción avanzada para el paso de compilación del shell Execute!

Puede simplemente elegir y establecer un valor de salida arbitrario; si coincide, la construcción será inestable. Simplemente elija un valor que no sea probable que sea lanzado por un proceso real en su compilación.

Answer 8

Pensé que publicaría otra respuesta para las personas que podrían estar buscando algo similar.

En nuestro trabajo de construcción tenemos casos en los que queremos que la construcción continúe, pero se marque como inestable. Para nosotros está relacionado con los números de versión.

Por lo tanto, quería establecer una condición en la compilación y establecer la construcción en inestable si se cumple esa condición.

Utilicé la opción Paso condicional (individual) como un paso de compilación.

Luego utilicé el script Execute System Groovy como el paso de compilación que se ejecutaría cuando se cumpla esa condición.

Usé Groovy Command y configuré el script de la siguiente manera

import hudson.model.*

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

return

Eso parece funcionar bastante bien.

Me encontré con la solución aquí

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

Answer 9

Se puede hacer sin imprimir cadenas mágicas y usar TextFinder. Here''s algo de información sobre esto.

Básicamente necesita un archivo .jar de http: // yourserver.com / cli disponible en scripts de shell, luego puede usar el siguiente comando para marcar una compilación inestable:

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

Para marcar la compilación inestable por error, puede usar:

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

El problema es que jenkins-cli.jar debe estar disponible desde el script de shell. Puede ponerlo en una ruta fácil de acceder o descargar en el script de shell de la tarea:

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

Answer 10

Si el intérprete de comandos finaliza con el comando fallido, todo está bien (la compilación falló :) En el caso de un comando fallido dentro del guión del intérprete de comandos, haga el siguiente comando:

 if [ "$?" -ne 0 ]; then
    exit 1
 fi 

Corrección de @zrajm: podría simplificarse a

... || exit 1

Answer 11

Simplemente puede llamar a "exit 1" y la construcción fallará en ese punto y no continuará. Terminé haciendo una función de paso a paso para manejarlo por mí, y llamo safemake en lugar de hacer para construir:

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

Answer 12

Use el complemento Text-finder .

En lugar de salir con el estado 1 (que no pasaría la compilación), hazlo:

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

Que en las acciones posteriores a la creación, habilite Text Finder, configure la expresión regular para que coincida con el mensaje que imprimió ( TESTS FAILED! ) Y marque la casilla "Unstable if found" debajo de esa entrada.

Answer 13

también debería ser capaz de usar groovy y hacer lo que hizo textfinder

marcando una compilación como no estable con un plugin post-build maravilloso

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()
}

Ver también el complemento Groovy Postbuild

Answer 14

Duplicando mi respuesta desde here porque pasé un tiempo buscando esto:

Esto ahora es posible en las versiones más nuevas de Jenkins, puedes hacer algo como esto:

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

El generador de sintaxis de Pipeline le muestra esto en la pestaña avanzada: