Хотелось бы. Но если только костыли ставить — переживу :)

Быстрый тест показывает что как будто в порядке добавления в мапу 🤔

Добавь sleep в каждый (помножить на коэф связанный с порядком добавления)

Сделал такой костыль, так как нужен был интервал (по очереди стартуют) , но в параллель дальше

Кажется, вопрос снят:

echo(BUILDS.getClass().toString()) // class java.util.LinkedHashMap

Из доков java:

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order)

echo(BUILDS.getClass().toString()) // class java.util.LinkedHashMap

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order)

это тоже хорошо, что порядок

Hi I need help in jenkins file

Build archive artifact consists of tar.gz

Which is storing in remote pdrive

I want get it the tar.gz files inside content in job console output to access the html files directly through ex file://

Can someone help me how to get

Please ping me

Anyone there

Our jenkinsfile script

downstreamJobs = [:]    // map build_url : build_result
envVarList = []
job_environment = ""
job_build = ""
job_post = ""
job_utils = ""
String env_var_string = new String('')

def create_env_var_string() {
   def env_vars = new String("${ENV_VAR_STRING}").split(',')
   def env_vars_shell = []
   env_var_string = new String('')

   // read env vars from env_string
   env_vars.each { env_var ->
       if (env_var.contains('=')) {
           String new_env_var = new String(env_var.replaceAll("\\s",""))
           env_vars_shell.add(new String("export ${new_env_var}"))
           envVarList.add(new String("${new_env_var}"))
       }
   }

   // add special env vars
   env_vars_shell.add(new String("export CACHE=${DOCKER_WORKSPACE}/cache_rcar-3"))

   // now build one string that the shell can take as env var list
   env_vars_shell.each { env_var ->
       env_var_string = env_var_string + env_var + ' && '
   }

   // now remove last &&
   if (env_var_string.endsWith(' && ')) {
       int index = env_var_string.lastIndexOf(' && ');
       if (index > 0) {
           env_var_string = env_var_string.substring(0, index)
       }
   }
}

def prepare_docker_workspace() {
   def status

   // create deploy directory
   status = job_utils.create_folder("${DEPLOY_BUILDS}")
   if (status != 0) {
       error('deploy directory cannot be created')
   }

   // fetch all lfs files
   status = sh(returnStatus: true, script: "cd ${JENKINS_WORKSPACE} && repo forall -c git lfs pull")
   if (status != 0) {
       error('repo lfs pull failed')
   }

   // clean docker workspace
   status = job_utils.delete_folder("${DOCKER_WORKSPACE}")
   if (status != 0) {
       error('removing docker workspace failed')
   }

   // create out directory
   status = job_utils.create_folder("${OUT}")
   if (status != 0) {
       error('out directory cannot be created')
   }

   //copy jenkins workspace directory to docker workspace
   status = sh(returnStatus: true, script: "rsync -a --exclude \'yocto-packages\' ${JENKINS_WORKSPACE}/ ${DOCKER_WORKSPACE}")
   if (status != 0) {
       error('copying workspace to docker workspace failed')
   }
}

def yocto_build() {
   def status

   // activate SSTATE Mirror for all builds that are not
   // nightly and not a RB build
   if ((NIGHTLY == "false") && (BUILD_TYPE != "RB")) {
       env_var_string = env_var_string + " && export SSTATE_MIRROR_DIR=${NFS_SHARE_BUILD_LINUX}"
   }

   // run build environment and call execution script
   status = sh(returnStatus: true, script: """
       #!/bin/bash
       set +e
       set +x
       EXIT_CODE=0

       cd ${BUILDENV_SH_DIR}

       ./run_buildenv.sh --name=${DOCKER_CONTAINER_NAME} -wd=${DOCKER_WORKSPACE} -nfsd=${NFS_SHARE_BUILD_LINUX} \\
           -ypd=\"${WORKSPACE}/${JENKINS_WORKSPACE}/yocto-packages:${DOCKER_WORKSPACE}/yocto-packages\" \\
           --dns=10.243.80.201 -u=${USER} \\
           \"bash -c \'${env_var_string} && ${YOCTO_SH_DIR}/run_yocto_build.sh --machine=${BUILD_VARIANT}\'\" || EXIT_CODE=\$?

       exit \$EXIT_CODE
       """
   )
   if (status != 0) {
       error('yocto build failed')
   }

   // generate BoM
   status = job_build.generateBoM("${BUILD_VARIANT}")
   if (status != 0) {
       error("Generation of BoM failed for ${BUILD_VARIANT}")
   }

   // generate build report
   status = job_build.generateBuildReport("${BUILD_VARIANT}")
   if (status != 0) {
       error("Generation of build report failed for ${BUILD_VARIANT}")
   }
}

def deploy_artifacts(String check_code) {
   def status = job_utils.copy("${RESULT_DIR}/*", "${DEPLOY_BUILDS}")
   if ((status != 0) && (check_code == 'true')) {
       error('deploying artifacts failed')
   }
}

pipeline {
   agent { node { label 'LinuxSlaveBuild' } }

   options {
       timestamps()
       buildDiscarder(logRotator(numToKeepStr: '200', daysToKeepStr: '90'))
       authorizationMatrix([
           'hudson.model.Item.Workspace:pr_de12962_conti_vw_icas1',
           'hudson.model.Item.Build:pr_de12962_con

ti_vw_icas1'])
   }

   parameters {
       string(name: 'BASELINE', defaultValue: 'ICAS1-', description: '<p>Branch/tag of baseline repo</p>', trim: true)
       string(name: 'BUILD_VARIANT', defaultValue: 'icas1', description: '<p>Build variant to be build</p>', trim: true)
       string(name: 'ENV_VAR_STRING', defaultValue: '', description: '<p>comma separated list of env vars to be set</p>', trim: true)
       string(name: 'DEPLOY_BUILDS', defaultValue: '${DEPLOY_BUILD_BASE}/${JOB_NAME}/${BUILD_NUMBER}', description: '<p>linux path to store results</p>', trim: true)
       string(name: 'BUILD_DESCRIPTION', defaultValue: '', description: '<p>build description of upstream job</p>', trim: true)
   }

   environment {
       GROOVY_SCRIPT_PATH = "${WORKSPACE}/tools/jenkins/"
       DOCKER_CONTAINER_NAME = "${JOB_NAME}_${BUILD_NUMBER}"
       DOCKER_WORKSPACE = "${WORKSPACE}/docker_ws"
       SYSINT_TOOLS = "${DOCKER_WORKSPACE}/sysint_tools"
       BUILDENV_SH_DIR = "${SYSINT_TOOLS}/build"
       YOCTO_SH_DIR = "${DOCKER_WORKSPACE}/.repo/manifests/tools/jenkins"
       JENKINS_WORKSPACE = 'jenkins_workspace'
       RESULT_DIR = "docker_ws/neo_deploy"
       DEPLOY_BUILDS_DEBUG = "${DEPLOY_BUILDS}/debug"
       LINUX_BUILD_DIR = "${DOCKER_WORKSPACE}"
       OUT = "docker_ws/out"
       SRCREV_CHECK_FILE = "${OUT}/srcrev_check.txt"
   }

   stages {
       stage('Setup Jenkins') {
           steps {
               script {
                   println('Load Scripting')
                   try {
                       job_environment = load(env.GROOVY_SCRIPT_PATH + 'environment.groovy')
                       job_build = load(env.GROOVY_SCRIPT_PATH + 'build.groovy')
                       job_post = load(env.GROOVY_SCRIPT_PATH + 'post.groovy')
                       job_utils = load(env.GROOVY_SCRIPT_PATH + 'utils.groovy')
                   } catch (exc) {
                       println(exc.getMessage())
                       error('Loading script failed')
                   }

                   // convert env vars to usable string for shell
                   create_env_var_string()

                   withEnv(envVarList) {
                       env.NIGHTLY = NIGHTLY
                       env.SRCREV_CHECK = SRCREV_CHECK
                       env.BUILD_TYPE = BUILD_TYPE
                       env.PROJECT_NAME = PROJECT_NAME
                   }
               }
           }
       }
       stage("Checkout Baseline Repositories") {
           steps {
               buildDescription("${BUILD_DESCRIPTION}")
               checkout([$class: 'RepoScm', forceSync: true, manifestBranch: "${BASELINE}",
                         manifestFile: 'system.xml', manifestGroup: 'default,sourcecode', manifestPlatform: 'none',
                         manifestRepositoryUrl: 'git@gitext.company.com:ICAS1/baseline.git',
                         repoUrl: '/opt/ICAS1/repo/git-repo-clone.bundle', destinationDir: "${JENKINS_WORKSPACE}"])
           }
       }
       stage("Prepare Workspace") {
           steps {
               prepare_docker_workspace()
           }
       }
       stage("Run Yocto Build") {
           steps {
               yocto_build()
           }
       }
       stage('Run parallel tasks') {
           parallel {
               stage('Sync Yocto Cache') {
                   when {
                       anyOf {
                           environment name: 'BUILD_TYPE', value: 'RC';
                           environment name: 'BUILD_TYPE', value: 'CI';
                       }
                   }
                   steps {
                       script {
                           withEnv(envVarList) {
                               println('Sync Yocto Cache')
                               job_build.buildJob(
                                   "${PROJECT_NAME}_build_sync_cache",
                                   [
                                       string(name: 'UPSTREAM_NODE', value: "${NODE_NAME}"),

string(name: 'UPSTREAM_JOB_NAME', value: "${JOB_NAME}"),
                                       string(name: 'BUILD_DESCRIPTION', value: "${BUILD_DESCRIPTION}-${BUILD_VARIANT}")
                                   ],
                                   true)
                           }
                       }
                   }
               }
               stage('Run SRCREV Check') {
                   when {
                       environment name: 'SRCREV_CHECK', value: 'true'
                   }
                   steps {
                       script {
                           withEnv(envVarList) {
                               println('Run SRCREV Check')
                               status = job_build.srcrevCheck()
                               if (status != 0) {
                                   catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
                                       error('Run SRCREV check returned with exit code: ' + status)
                                   }
                               }
                           }
                       }
                   }

               }
               stage('Deploy and Archive Artifacts') {
                   steps {
                       deploy_artifacts('true')
                       archiveArtifacts(allowEmptyArchive: true, artifacts: "${RESULT_DIR}/debug/version_info/*.log")
                       archiveArtifacts(allowEmptyArchive: true, artifacts: "${OUT}/*")
                   }
               }
           }
       }
   }
   post {
       always {
           script {
               String text = new String("*This build was running on node: [${NODE_NAME}|${JENKINS_MASTER_URL_SSL}/computer/${NODE_NAME}]*")
               rtp nullAction: '1', parserName: 'Confluence', stableText: text
               job_environment.collectEnvVars()
               job_build.buildJob(
                   "${PROJECT_NAME}_export_job_config",
                       [
                           string(name: 'BRANCH', value: "devel"),
                           string(name: 'EXPORT_JOB_NAME', value: "${JOB_NAME}"),
                           string(name: 'DEPLOY_TO', value: "${DEPLOY_BUILDS_DEBUG}/config")
                       ],
                       false)
               job_build.buildJob(
                   "${PROJECT_NAME}_export_build_console",
                       [
                           string(name: 'EXPORT_JOB_NAME', value: "${JOB_NAME}"),
                           string(name: 'EXPORT_BUILD_NUMBER', value: "${BUILD_NUMBER}"),
                           string(name: 'DEPLOY_TO', value: "${DEPLOY_BUILDS_DEBUG}/log")
                       ],
                       false)
           }
       }
       failure {
           script {
               deploy_artifacts('false')
           }
       }
   }
}

This is my jenkinsfile

Please help me

$300

ah, sorry... you from India - $500