scripts - ¿Cómo puedo hacer referencia al directorio Jenkinsfile, con Pipeline?

jenkinsfile scripts

Question

Tengo un archivo maravilloso, quiero ejecutar desde el archivo Jenkins.

es decir. load script.groovy

Sin embargo, no estoy seguro de cómo puedo hacer referencia a este archivo si está almacenado en el mismo directorio que el archivo Jenkins. Estoy cargando el archivo Jenkins de git. Noté que crea una carpeta llamada workspace@script . No coloca esto en el directorio del área de trabajo. Podría codificar la carpeta pero no estoy seguro de las reglas sobre esto y parece un poco redundante revisar el código nuevamente.

java.io.FileNotFoundException: /opt/jenkins_home/jobs/my_job/workspace/script.groovy (No such file or directory)

Por defecto, se carga desde el espacio de trabajo, en lugar del workspace@script del workspace@script de workspace@script

Estoy intentando convertir un script BuildFlow en un script Pipeline (Workflow). Pero estoy encontrando, no es tan fácil como copiar y pegar.

Jenkinsfile

node {

//get parameters from Job
def builds = builds.tokenize(",")
def ip_address_node = ip_address_node.trim()
def port_node = port_node.trim()
def branch = branch.trim()
def workspace = pwd()

stage ''Checking out code from esb repository''
git branch: branch, url: ''ssh://git@giturl/integration_bus.git''

load ''../workspace@script/esb_deploybar_pipeline/deploy_esb.groovy''

}

deploy_esb.groovy (esto es desde el flujo de compilación anterior, intentando ejecutarse en una tubería)

import groovy.transform.ToString
import groovy.transform.EqualsAndHashCode
@EqualsAndHashCode
@ToString
class BarDeploy {
    String barFile
    String app
    String integrationServer
}


//parse csv
def csvItemsApps = new HashSet<BarDeploy>();
def csvItemsLibs = new HashSet<BarDeploy>();
def deploymentMapFile = new File(workspace + "/ESB_Deployment_Map.csv")
def isFirstLine = true

stage ''Parsing ESB Deployment CSV''
deploymentMapFile.withReader { reader ->
    while(line = reader.readLine()) {
        if(isFirstLine)
        {
          isFirstLine = false
          continue
        }

        csvLine = line.split(",")
        app = csvLine[0]
        intServer = csvLine[1]

        def barDeploy = new BarDeploy()
        barDeploy.app = app
        barDeploy.integrationServer = intServer
        csvItemsApps.add(barDeploy)


        //get shared libs
        if(csvLine.length > 2 && csvLine[2] != null)
        {
            def sharedLibs = csvLine[2].split(";")
            sharedLibs.each { libString ->
                if(!libString.isAllWhitespace())
                {
                    def lib = new BarDeploy()
                    lib.app = libString
                    lib.integrationServer = intServer
                    csvItemsLibs.add(lib)
                }
            };
        }
    }
};

//get list of bar files to deploy from html and consolidate bar files to deploy with apps in csv 
for (int i = 0; i < builds.size(); i+=3)
{
    if(builds[i].equals("false"))
    {
        //Don''t deploy bar if checkbox isn''t selected
        continue
    }

    foundInCSV = false

    appToDeploy = builds[i + 1]
    barFileToDeploy = builds[i + 2]

    iterator = csvItemsApps.iterator()
    while (iterator.hasNext())
    {
        barDeploy = iterator.next()
        if(appToDeploy.equalsIgnoreCase(barDeploy.app))
        {
            barDeploy.barFile = barFileToDeploy
            foundInCSV = true
        }
    }

    iterator = csvItemsLibs.iterator()
    while (iterator.hasNext())
    {
        barDeploy = iterator.next()
        if(appToDeploy.equalsIgnoreCase(barDeploy.app))
        {
            barDeploy.barFile = barFileToDeploy
            foundInCSV = true
        }
    }

    if(foundInCSV == false)
    {
        throw new RuntimeException("App: " + appToDeploy + " not found in ESB_Deployment_Map.csv. Please add CSV Entry.")
    }
}


//Do deploy, deploy shared libs first
deployCSVItemsInParallel(ip_address_node,port_node,branch,env_key,csvItemsLibs)
deployCSVItemsInParallel(ip_address_node,port_node,branch,env_key,csvItemsApps)


def deploy(ip_address_node,port_node,branch,deployItem,env_key)
{
    def integrationServer = deployItem.integrationServer
    def app = deployItem.app
    def barFile = deployItem.barFile

    if(barFile == null)
    {
        return;
    }

    println("Triggering Build -> ESB App = " + app +  ", Branch = " 
            + branch + ", Barfile: " + barFile + ", Integration Server = " + integrationServer + ", IP Address: " + ip_address_node 
            + ", Port: " + port_node + ", Env_Key: " + env_key)

    build_closure = { ->
        build("esb_deploybar", 
                      ip_address_node: ip_address_node, port_node: port_node,
                      integrationServer: integrationServer, branch: branch, app: app, barFile: barFile, env_key: env_key)
    }

    return build_closure
}

def deployCSVItemsInParallel(ip_address_node,port_node,branch,env_key,csvItems)
{
    def build_closures = []
    iterator = csvItems.iterator()
    while (iterator.hasNext())
    {
      barDeploy = iterator.next()
      def build_closure = deploy(ip_address_node,port_node,branch,barDeploy,env_key)

      if(build_closure != null)
      {
          build_closures.add(build_closure)
      }
    }

    if(build_closures?.size() > 0)
    {
         parallel(build_closures)
    }
}

Answer 1

Esto debería funcionar

load "${WORKSPACE}/../${JOB_NAME}@script/esb_deploy/esb_deploybar_pipeline/deploy_esb.groovy"

Answer 2

Hay un escenario que no he visto mencionar a nadie. Que es cómo cargar los scripts Groovy cuando se supone que el trabajo debe ejecutarse en un agente / esclavo Jenkins, en lugar de en el maestro .

Dado que el maestro es el que verifica el proyecto de tubería Jenkins de SCM, los scripts Groovy solo se encuentran en el sistema de archivos del maestro . Así que mientras esto funcione:

node {       
    def workspace = pwd() 
    def Bar = load "${workspace}@script/Bar.groovy"
    Bar.doSomething()
}

Es solo una coincidencia feliz porque el nodo que clona la canalización de SCM es el mismo que intenta cargar las secuencias de comandos en él. Sin embargo, solo agregando el nombre de un agente diferente para ejecutar en:

node("agent1"){
    def workspace = pwd() 
    def Bar = load "${workspace}@script/Bar.groovy"
    Bar.doSomething()
}

Fallará, resultando en:

java.io.IOException: java.io.FileNotFoundException: /Jenkins/workspace/Foo_Job@script/Bar.groovy (No such file or directory)

Esto es porque este camino:

/Jenkins/workspace/Foo_Job@script/

Solo existe en la caja del maestro Jenkins. No en el cuadro ejecutando agent1 .

Entonces, si estás enfrentando este problema, asegúrate de cargar los guiones geniales del maestro en las variables declaradas globalmente, para que el agente pueda usarlas:

def Bar
node {       
    def workspace = pwd() 
    if(isUnix()){
        Bar = load "${workspace}@script/Bar.groovy"
    }
    else{
        Bar = load("..//workspace@script//Bar.groovy")
    }
}
node("agent1"){
    Bar.doSomething()
}

Nota: La variable utilizada para pasar el módulo entre nodos debe declararse fuera de los bloques de nodos .

Answer 3

Si el archivo deploy_esb.groovy se almacena en el mismo SCM que el archivo Jenkins, puede hacer:

node {       
   def workspace = pwd() 
   load "${workspace}@script/esb_deploybar_pipeline/deploy_esb.groovy"
}

Answer 4

Si este archivo script.groovy está en la raíz de su proyecto, como el archivo Jenkins, se buscará desde git en la misma carpeta que su archivo Jenkins. Así que el comando que está utilizando debería funcionar bien.

¿Estás recibiendo algún error? Por favor, proporcione más detalles si es así.

EDITAR: ahora puedo ver lo que está en su archivo Jenkins, puedo ver que está revisando un proyecto git llamado integration_bus, que es donde reside el script groovy. Puede especificar la ubicación donde se extrae de esta manera:

checkout([$class: ''GitSCM'', branches: [[name: ''*/master'']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: ''RelativeTargetDirectory'', relativeTargetDir: ''esb_deploy'']], submoduleCfg: [], userRemoteConfigs: [[url: ''ssh://git@giturl/integration_bus.git'']]])

a diferencia de lo que tienes

git branch: branch, url: ''ssh://git@giturl/integration_bus.git''

Entonces deberías poder hacer referencia a la secuencia de comandos groovy en la carpeta esb_deploy como esta

load ''esb_deploy/esb_deploybar_pipeline/deploy_esb.groovy''

Answer 5

Solo puede asumir que todas las operaciones de archivo en el archivo Jenkinsfile son relativas al espacio de trabajo actual (que es el espacio de trabajo predeterminado cuando se usa la load dentro de un node ).

Entonces, si el archivo de destino (por ejemplo, deploy_esb.groovy ) está dentro de la carpeta foo en su SCM, esto debería funcionar sin configuración adicional:

git branch: branch, url: ''ssh://git@giturl/integration_bus.git''
load ''foo/deploy_esb.groovy''

O esto si el archivo a cargar está en el mismo repositorio que el Jenkinsfile :

checkout scm
load ''foo/deploy_esb.groovy''

Answer 6

Tenía el mismo problema. Terminé con una operación de clonación adicional para obtener una copia del repositorio de scripts en el directorio de espacio de trabajo, de modo que puedo acceder de manera confiable a los archivos groovy en él

dir (''SCRIPTS_DIR'') {
    checkout scm
    commonScripts = load ''subdir/Common.groovy'' // no def, so script is global
}