¿Cómo puedo activar la creación de otro trabajo desde dentro Jenkinsfile?

Supongo que este trabajo es otro repositorio bajo la misma organización github , uno que ya tiene su propio archivo Jenkins.

También quiero hacer esto solo si el nombre de la sucursal es maestro, ya que no tiene sentido desencadenar compilaciones posteriores de cualquier sucursal local.

Actualizar:

stage 'test-downstream'
node {
     def job = build job: 'some-downtream-job-name'
}

Aún así, cuando se ejecuta me sale un error

No se encontró trabajo parametrizado llamado some-downtream-job-name

Estoy seguro de que este trabajo existe en jenkins y está bajo la misma carpeta de organización que la actual. Es otro trabajo que tiene el suyo Jenkinsfile.

Tenga en cuenta que esta pregunta es específica del complemento de organización de GitHub que crea y mantiene automáticamente trabajos para cada repositorio y sucursal de su organización de GitHub.

En primer lugar, es un desperdicio de un espacio de ejecución para completar el buildpaso node. Su ejecutor corriente arriba estará inactivo sin ninguna razón.

En segundo lugar, desde un proyecto de varias ramas, puede usar la variable de entorno BRANCH_NAMEpara hacer que la lógica sea condicional en la rama actual.

Tercero, el jobparámetro toma un nombre de trabajo absoluto o relativo. Si da un nombre sin ninguna calificación de ruta, eso se referiría a otro trabajo en la misma carpeta, lo que en el caso de un proyecto de varias ramas significaría otra rama del mismo repositorio.

Por lo tanto, lo que querías escribir es probablemente

if (env.BRANCH_NAME == 'master') {
    build '../other-repo/master'
}

Además de las respuestas mencionadas anteriormente: quería comenzar un trabajo con un parámetro simple pasado a una segunda tubería y encontré la respuesta en https://dzone.com/refcardz/continuous-delivery-with-jenkins-workflow .

Entonces usé:

stage ('Starting ART job') {
    build job: 'RunArtInTest', parameters: [[$class: 'StringParameterValue', name: 'systemname', value: systemname]]
}

El comando builden la tubería está ahí para activar otros trabajos en jenkins.

Ejemplo en github

El trabajo debe existir en Jenkins y puede parametrizarse. En cuanto a la rama, supongo que puedes leerla desde git

Puede utilizar el build jobpaso de Jenkins Pipeline (requisito mínimo de Jenkins: 2.130).

Aquí está la API completa para el buildpaso: https://jenkins.io/doc/pipeline/steps/pipeline-build-step/

Cómo utilizar build:

• job: Nombre de un trabajo posterior para construir. Puede ser otro trabajo de Pipeline, pero más comúnmente un estilo libre u otro proyecto.
  • Utilice un nombre simple si el trabajo está en la misma carpeta que este trabajo de canalización ascendente;
  • En su lugar, puede usar rutas relativas como../sister-folder/downstream
  • O puedes usar rutas absolutas como/top-level-folder/nested-folder/downstream

Activa otro trabajo usando una rama como parámetro

En mi empresa, muchas de nuestras sucursales incluyen "/". Debe reemplazar cualquier instancia de "/" con "% 2F" (como aparece en la URL del trabajo).

En este ejemplo estamos usando rutas relativas

    stage('Trigger Branch Build') {
        steps {
            script {
                    echo "Triggering job for branch ${env.BRANCH_NAME}"
                    BRANCH_TO_TAG=env.BRANCH_NAME.replace("/","%2F")
                    build job: "../my-relative-job/${BRANCH_TO_TAG}", wait: false
            }
        }
    }

Activa otro trabajo usando el número de compilación como parámetro

build job: 'your-job-name', 
    parameters: [
        string(name: 'passed_build_number_param', value: String.valueOf(BUILD_NUMBER)),
        string(name: 'complex_param', value: 'prefix-' + String.valueOf(BUILD_NUMBER))
    ]

Desencadenar muchos trabajos en paralelo

Fuente: https://jenkins.io/blog/2017/01/19/converting-conditional-to-pipeline/

Más información sobre Paralelo aquí: https://jenkins.io/doc/book/pipeline/syntax/#parallel

    stage ('Trigger Builds In Parallel') {
        steps {
            // Freestyle build trigger calls a list of jobs
            // Pipeline build() step only calls one job
            // To run all three jobs in parallel, we use "parallel" step
            // https://jenkins.io/doc/pipeline/examples/#jobs-in-parallel
            parallel (
                linux: {
                    build job: 'full-build-linux', parameters: [string(name: 'GIT_BRANCH_NAME', value: env.BRANCH_NAME)]
                },
                mac: {
                    build job: 'full-build-mac', parameters: [string(name: 'GIT_BRANCH_NAME', value: env.BRANCH_NAME)]
                },
                windows: {
                    build job: 'full-build-windows', parameters: [string(name: 'GIT_BRANCH_NAME', value: env.BRANCH_NAME)]
                },
                failFast: false)
        }
    }

O alternativamente:

    stage('Build A and B') {
            failFast true
            parallel {
                stage('Build A') {
                    steps {
                            build job: "/project/A/${env.BRANCH}", wait: true
                    }
                }
                stage('Build B') {
                    steps {
                            build job: "/project/B/${env.BRANCH}", wait: true
                    }
                }
            }
    }

Utilice el complemento de trabajo de compilación para esa tarea para activar otros trabajos desde el archivo jenkins. Puede agregar una variedad de lógica a su ejecución, como opciones paralelas, de nodo y agentes, y pasos para activar trabajos externos. Le di un ejemplo de libro de cocina fácil de leer para eso.

1.ejemplo para activar un trabajo externo desde un archivo jenkins con un ejemplo condicional:

if (env.BRANCH_NAME == 'master') {
  build job:'exactJobName' , parameters:[
    string(name: 'keyNameOfParam1',value: 'valueOfParam1')
    booleanParam(name: 'keyNameOfParam2',value:'valueOfParam2')
 ]
}

2.ejemplo que desencadena múltiples trabajos desde el archivo jenkins con ejemplos condicionales:

 def jobs =[
    'job1Title'{
    if (env.BRANCH_NAME == 'master') {
      build job:'exactJobName' , parameters:[
        string(name: 'keyNameOfParam1',value: 'valueNameOfParam1')
        booleanParam(name: 'keyNameOfParam2',value:'valueNameOfParam2')
     ]
    }
},
    'job2Title'{
    if (env.GIT_COMMIT == 'someCommitHashToPerformAdditionalTest') {
      build job:'exactJobName' , parameters:[
        string(name: 'keyNameOfParam3',value: 'valueOfParam3')
        booleanParam(name: 'keyNameOfParam4',value:'valueNameOfParam4')
        booleanParam(name: 'keyNameOfParam5',value:'valueNameOfParam5')
     ]
    }
}