¿Cómo desencadenar dinámicamente versiones posteriores en jenkins?

Question

Queremos activar dinámicamente pruebas de integración en diferentes compilaciones posteriores en jenkins. Tenemos un proyecto de prueba de integración parametrizada que toma un nombre de prueba como parámetro. Determinamos dinámicamente nuestros nombres de prueba del repositorio git.

Tenemos un proyecto principal que utiliza Jenkins-CLI para iniciar una construcción del proyecto de integración para cada prueba que se encuentra en el código fuente. El proyecto principal y el proyecto de integración se relacionan a través de huellas dactilares coincidentes.

El problema con este enfoque es que los resultados de las pruebas agregadas no funciona. Creo que el problema es que las pruebas de integración "aguas abajo" se inician a través de jenkins-cli, por lo que jenkins no se da cuenta de que están en proceso.

He mirado en muchos Jenkins plugins para tratar de conseguir este trabajo. Los complementos Unir y Activador parametrizado no ayudan porque esperan una lista estática de proyectos para compilar. Las fábricas de parámetros disponibles para el Disparador parametrizado tampoco funcionarán porque no hay fábrica para crear una lista arbitraria de parámetros. El complemento Log Trigger no funcionará.

El maravilloso Postbuild Plugin parece que debería funcionar, pero no pude encontrar la manera de desencadenar una acumulación de ella.

Answer 1

def job = hudson.model.Hudson.instance.getJob("job") 
def params = new StringParameterValue('PARAMTEST', "somestring") 
def paramsAction = new ParametersAction(params) 
def cause = new hudson.model.Cause.UpstreamCause(currentBuild) 
def causeAction = new hudson.model.CauseAction(cause) 
hudson.model.Hudson.instance.queue.schedule(job, 0, causeAction, paramsAction) 

Esto es lo que finalmente funcionó para mí.

Answer 2

Dado que ya está comenzando los trabajos indirectos dinámicamente, qué tal si espera hasta que terminen y copien los archivos de resultados de prueba (los archivaría en los trabajos indirectos y luego simplemente descargue los artefactos de compilación) en el espacio de trabajo padre . Es posible que necesite agregar los archivos manualmente, dependiendo de si el complemento de prueba puede funcionar con varias páginas de resultados de prueba. En el paso posterior a la compilación de los trabajos principales, configure el complemento de prueba apropiado.

Answer 3

Utilizando el maravilloso Postbuild Plugin, tal vez algo como esto va a funcionar (no lo he probado)

def job = hudson.getItem(jobname) 
hudson.queue.schedule(job) 

De hecho, estoy sorprendido de que si ambos trabajos huella digital (por ejemplo, con la variable BUILD_TAG del trabajo de los padres) los resultados agregados no son recogidos. En mi entendimiento Jenkins simplemente mira md5sums de relacionarse puestos de trabajo (Aggregate downstream test results y activar a través de la CLI no debe afectar la agregación de resultados. De alguna manera, hay algo adicional que va a mantener la relación aguas arriba/aguas abajo que no soy consciente de ...

Answer 4

NOTA: El Pipeline Plugin debe hacer esta pregunta discutible, pero no he tenido la oportunidad de actualizar nuestra infraestructura

para iniciar un trabajo corriente abajo sin parámetros:.

job = manager.hudson.getItem(name) 
cause = new hudson.model.Cause.UpstreamCause(manager.build) 
causeAction = new hudson.model.CauseAction(cause) 
manager.hudson.queue.schedule(job, 0, causeAction) 

para iniciar un trabajo corriente abajo con parámetros, hay que añadir un ParametersAction. Supongamos que Job1 tiene los parámetros A y C que por defecto son "B" y "D", respectivamente. Es decir .:

A == "B" 
C == "D" 

Supongamos Job2 tiene los mismos parámetros A y B, pero también toma parámetro E que por defecto es "F".El siguiente script de construcción posterior en Job1 copiará sus parámetros A y C y ajustar el parámetro E a la concatenación de A 's y C' valores de s:

params = [] 
val = '' 
manager.build.properties.actions.each { 
    if (it instanceof hudson.model.ParametersAction) { 
     it.parameters.each { 
      value = it.createVariableResolver(manager.build).resolve(it.name) 
      params += it 
      val += value 
     } 
    } 
} 

params += new hudson.model.StringParameterValue('E', val) 
paramsAction = new hudson.model.ParametersAction(params) 

jobName = 'Job2' 
job = manager.hudson.getItem(jobName) 
cause = new hudson.model.Cause.UpstreamCause(manager.build) 
causeAction = new hudson.model.CauseAction(cause) 
def waitingItem = manager.hudson.queue.schedule(job, 0, causeAction, paramsAction) 
def childFuture = waitingItem.getFuture() 
def childBuild = childFuture.get() 

hudson.plugins.parameterizedtrigger.BuildInfoExporterAction.addBuildInfoExporterAction(
    manager.build, childProjectName, childBuild.number, childBuild.result 
) 

hay que añadir $JENKINS_HOME/plugins/parameterized-trigger/WEB-INF/classes a de Additional groovy classpath el plugin maravilloso Postbuild.

Answer 5

Esto funcionó para mí el uso de "Ejecutar sistema maravilloso guión "

import hudson.model.* 

def currentBuild = Thread.currentThread().executable 

def job = hudson.model.Hudson.instance.getJob("jobname") 
def params = new StringParameterValue('paramname', "somestring") 
def paramsAction = new ParametersAction(params) 
def cause = new hudson.model.Cause.UpstreamCause(currentBuild) 
def causeAction = new hudson.model.CauseAction(cause) 
hudson.model.Hudson.instance.queue.schedule(job, 0, causeAction, paramsAction) 

Answer 6

Ejecutar este script Groovy

import hudson.model.* 
import jenkins.model.* 

def build = Thread.currentThread().executable 

def jobPattern = "PUTHEREYOURJOBNAME"  
def matchedJobs = Jenkins.instance.items.findAll { job -> 
    job.name =~ /$jobPattern/ 
} 
matchedJobs.each { job -> 
    println "Scheduling job name is: ${job.name}" 
    job.scheduleBuild(1, new Cause.UpstreamCause(build), new ParametersAction([ new StringParameterValue("PROPERTY1", "PROPERTY1VALUE"),new StringParameterValue("PROPERTY2", "PROPERTY2VALUE")])) 
} 

Si no necesita pasar de las propiedades de una estructura a la otra solo saca la opción Parámetros.

La construcción que programó tendrá la misma "causa" que su compilación inicial. Esa es una buena manera de pasar los "Cambios". Si no lo necesita, simplemente no use Cause.UpstreamCause (compilación) nuevo en la llamada de función