web-dev-qa-db-fra.com

Comment puis-je référencer le répertoire Jenkinsfile, avec Pipeline?

J'ai un fichier groovy, je veux courir à partir du fichier Jenkins.

c'est à dire. load script.groovy

Cependant, je ne sais pas comment référencer ce fichier s'il est stocké dans le même répertoire que le fichier Jenkins. Je charge le fichier Jenkins à partir de git. J'ai remarqué qu'il crée un dossier appelé workspace@script. Cela ne le place pas dans le répertoire de l'espace de travail. Je pourrais coder le dossier en dur mais je ne suis pas sûr des règles à ce sujet et il semble un peu redondant de vérifier le code à nouveau. 

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

Par défaut, il se charge depuis l'espace de travail au lieu de workspace@script

J'essaie de convertir un script BuildFlow en script Pipeline (flux de travail). Mais je trouve, ce n'est pas aussi facile qu'un copier-coller. 

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 (il s'agit d'un ancien buildflow qui tente de s'exécuter dans un pipeline)

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)
    }
}
jenkinsgroovyjenkins-workflowjenkins-pipelinejenkinsfile
24
CodyK

Si le fichier deploy_esb.groovy est stocké dans le même SCM que le fichier Jenkins, vous pouvez procéder comme suit:

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

Il y a un scénario que je n'ai vu personne mentionner. Comment charger les scripts Groovy lorsque le travail est censé être exécuté sur un Jenkins agent/slave plutôt que sur le master.

Comme le maître est celui qui extrait le projet de pipeline Jenkins dans SCM, les scripts Groovy ne se trouvent que dans le système de fichiers du maître. Donc, pendant que cela fonctionnera:

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

Ce n'est qu'une heureuse coïncidence, car le nœud qui clone le pipeline à partir de SCM est le même que celui qui tente de charger les scripts groovy qu'il contient. Cependant, il suffit d'ajouter le nom d'un autre agent à exécuter:

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

Échouera, entraînant:

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

C'est parce que ce chemin:

/Jenkins/workspace/Foo_Job@script/

N'existe que sur la boîte maître Jenkins. Pas dans la boîte en cours d'exécution agent1.

Donc, si vous rencontrez ce problème, assurez-vous de charger les scripts groovy du maître dans des variables déclarées globalement, afin que l'agent puisse ensuite les utiliser:

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

Remarque: La variable utilisée pour passer le module entre les nœuds doit être déclarée en dehors de les blocs node.

9
Mig82

si ce fichier script.groovy se trouve à la racine de votre projet, comme le fichier Jenkins, il sera extrait de git dans le même dossier que votre fichier Jenkins. La commande que vous utilisez devrait donc fonctionner correctement.

Avez-vous une erreur? S'il vous plaît fournir plus de détails si oui.

EDIT: je peux maintenant voir ce que contient votre fichier Jenkins, je vois que vous êtes en train de vérifier un projet git appelé integration_bus, où se trouve le script groovy. Vous pouvez spécifier l'emplacement où cela est extrait comme ceci:

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

par opposition à ce que vous avez

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

Ensuite, vous devriez pouvoir référencer le script groovy dans le dossier esb_deploy comme ceci

load 'esb_deploy/esb_deploybar_pipeline/deploy_esb.groovy'
1
Mark Chorley

Avait le même problème. Nous avons obtenu une opération de clonage supplémentaire pour obtenir une copie du dépôt de script sous le répertoire workspace afin que je puisse accéder de manière fiable aux fichiers groovy qu'il contient:

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

Vous pouvez simplement supposer que toutes les opérations sur les fichiers de la variable Jenkinsfile sont relatives à l'espace de travail actuel (qui est l'espace de travail par défaut lorsque vous utilisez load dans une variable node).

Ainsi, si le fichier cible (par exemple deploy_esb.groovy) se trouve dans le dossier foo de votre GDS, cela devrait fonctionner sans configuration supplémentaire:

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

Ou ceci si le fichier à charger se trouve dans le même référentiel que le Jenkinsfile:

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

Cela devrait marcher

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