Come posso fare riferimento alla directory Jenkinsfile, con Pipeline?

Question

Ho un file groovy, voglio correre dal Jenkinsfile.

ie. load script.groovy

Tuttavia, non sono sicuro di come posso fare riferimento a questo file se è memorizzato nella stessa directory del file Jenkins. Sto caricando il Jenkinsfile da Git. Ho notato che crea una cartella denominata workspace@script. Non lo posiziona nella directory dello spazio di lavoro. Potrei hardcode la cartella ma non sono sicuro delle regole su questo e sembra un po 'ridondante per controllare di nuovo il codice.

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

Di default viene caricato da lavoro, invece di workspace@script

Sto cercando di convertire un uno script BuildFlow a uno script Pipeline (Workflow). Ma sto trovando, non è così facile come una copia e incolla.

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 (questo è da vecchi buildflow, cercando di eseguire in una 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) 
    } 
} 

Answer 1

se questo file script.groovy è nella root del vostro progetto, come il Jenkinsfile, verrà scaricato da git nella stessa cartella del tuo Jenkinsfile. Quindi il comando che stai usando dovrebbe funzionare bene.

Stai riscontrando un errore? Si prega di fornire maggiori dettagli in tal caso.

EDIT: ora posso vedere cosa c'è nel tuo Jenkinsfile, vedo che stai controllando un progetto git chiamato integration_bus che è il posto dove risiede lo script groovy. È possibile specificare la posizione in cui che è stato estratto in questo modo:

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

al contrario di quello che hai

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

Poi si dovrebbe essere in grado di fare riferimento allo script Groovy nella cartella esb_deploy come questo

Answer 2

Si può semplicemente presumere che tutte le operazioni sui file nello Jenkinsfile siano relative allo spazio di lavoro corrente (che è lo spazio di lavoro predefinito quando si utilizza load all'interno di un node).

Quindi, se il file di destinazione (ad esempio deploy_esb.groovy) si trova all'interno della cartella foo nel vostro SCM, questo dovrebbe funzionare senza ulteriore configurazione:

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

O questo, se il file da caricare è nella stessa repository rispetto alla Jenkinsfile:

checkout scm 
load 'foo/deploy_esb.groovy' 

Answer 3

Se deploy_esb.groovy file viene memorizzato nella stessa SCM come il Jenkinsfile si può fare:

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

Answer 4

C'è uno scenario che non ho visto nessuno menzionare.Ecco come caricare gli script di Groovy quando il lavoro deve essere eseguito su un agente/slave Jenkins , anziché sul master.

Poiché il master è quello che controlla il progetto del gasdotto Jenkins da SCM, , gli script di Groovy si trovano solo nel file system del master. Così, mentre questo lavoro:

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

E 'solo una coincidenza felice perché il nodo che clona il gasdotto che collega SCM è la stessa che tenta di caricare gli script Groovy in esso. Tuttavia, semplicemente aggiungendo il nome di un agente diverso da eseguire su:

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

fallirà, con conseguente:

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

Questo è perché questo percorso:

/Jenkins/workspace/Foo_Job@script/ 

esiste solo sulla la scatola del maestro Jenkins. Non nella scatola in esecuzione agente1.

Quindi, se siete di fronte a questo problema, assicurarsi di caricare gli script groove dal master in dichiarata globalmente variabili, in modo l'agente può poi usarli:

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 variabile utilizzato per passare il modulo tra i nodi deve essere dichiarato all'esterno del del nodo blocchi.