<?xml version="1.0" encoding="UTF-8"?><project>
  <actions/>
  <description>&lt;!-- Managed by Jenkins Job Builder --&gt;</description>
  <keepDependencies>false</keepDependencies>
  <disabled>false</disabled>
  <displayName>TCWG Precommit tcwg_gnu_embed_check_binutils/master-thumb_m23_soft_eabi</displayName>
  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
  <concurrentBuild>true</concurrentBuild>
  <customWorkspace>workspace/tcwg_gnu_$EXECUTOR_NUMBER</customWorkspace>
  <assignedNode>tcwg-build &amp;&amp; tcwg-x86_64 &amp;&amp; tcwg-precommit &amp;&amp; jenkins-01</assignedNode>
  <canRoam>false</canRoam>
  <properties>
    <hudson.security.AuthorizationMatrixProperty>
      <permission>hudson.model.Item.Read:anonymous</permission>
      <permission>hudson.model.Item.ExtendedRead:anonymous</permission>
      <permission>hudson.model.Item.Build:everyone-flat</permission>
      <permission>hudson.model.Item.Cancel:everyone-flat</permission>
    </hudson.security.AuthorizationMatrixProperty>
    <jenkins.model.BuildDiscarderProperty>
      <strategy class="hudson.tasks.LogRotator">
        <daysToKeep>20</daysToKeep>
        <numToKeep>-1</numToKeep>
        <artifactDaysToKeep>-1</artifactDaysToKeep>
        <artifactNumToKeep>-1</artifactNumToKeep>
      </strategy>
    </jenkins.model.BuildDiscarderProperty>
    <hudson.plugins.buildblocker.BuildBlockerProperty>
      <useBuildBlocker>true</useBuildBlocker>
      <blockingJobs>tcwg_gnu_embed_check_binutils--master-thumb_m23_soft_eabi-build</blockingJobs>
      <blockLevel>GLOBAL</blockLevel>
      <scanQueueFor>BUILDABLE</scanQueueFor>
    </hudson.plugins.buildblocker.BuildBlockerProperty>
    <hudson.model.ParametersDefinitionProperty>
      <parameterDefinitions>
        <hudson.model.StringParameterDefinition>
          <name>binutils_git</name>
          <description>binutils git_url#branch/sha1 to build, or 'default', 'baseline' or 'jenkins-scm', or pw://series/&lt;id&gt; to build with patches from patchwork ('precommit' mode, use 'pw://series/&lt;id&gt;/retrigger/' to force a rebuild)</description>
          <defaultValue>baseline</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>gcc_git</name>
          <description>gcc git_url#branch/sha1 to build, or 'default', 'baseline' or 'jenkins-scm', or pw://series/&lt;id&gt; to build with patches from patchwork ('precommit' mode, use 'pw://series/&lt;id&gt;/retrigger/' to force a rebuild)</description>
          <defaultValue>baseline</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>gdb_git</name>
          <description>gdb git_url#branch/sha1 to build, or 'default', 'baseline' or 'jenkins-scm', or pw://series/&lt;id&gt; to build with patches from patchwork ('precommit' mode, use 'pw://series/&lt;id&gt;/retrigger/' to force a rebuild)</description>
          <defaultValue>baseline</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>newlib_git</name>
          <description>newlib git_url#branch/sha1 to build, or 'default', 'baseline' or 'jenkins-scm', or pw://series/&lt;id&gt; to build with patches from patchwork ('precommit' mode, use 'pw://series/&lt;id&gt;/retrigger/' to force a rebuild)</description>
          <defaultValue>baseline</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>qemu_git</name>
          <description>qemu git_url#branch/sha1 to build, or 'default', 'baseline' or 'jenkins-scm', or pw://series/&lt;id&gt; to build with patches from patchwork ('precommit' mode, use 'pw://series/&lt;id&gt;/retrigger/' to force a rebuild)</description>
          <defaultValue>baseline</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>notify</name>
          <description>Email to send failure notifications to</description>
          <defaultValue>precommit</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>extra_build_params</name>
          <description>Extra parameters to pass to the build script; can be used to override settings extracted from ci_project/ci_config</description>
          <defaultValue/>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>distro</name>
          <description>Distro image to use</description>
          <defaultValue>default</defaultValue>
        </hudson.model.StringParameterDefinition>
        <hudson.model.StringParameterDefinition>
          <name>scripts_branch</name>
          <description>Scripts revision to use</description>
          <defaultValue>master</defaultValue>
        </hudson.model.StringParameterDefinition>
      </parameterDefinitions>
    </hudson.model.ParametersDefinitionProperty>
  </properties>
  <scm class="hudson.plugins.git.GitSCM">
    <configVersion>2</configVersion>
    <userRemoteConfigs>
      <hudson.plugins.git.UserRemoteConfig>
        <name>origin</name>
        <refspec>+refs/heads/*:refs/remotes/origin/* +refs/changes/*:refs/changes/*</refspec>
        <url>https://gitlab.com/LinaroLtd/tcwg/jenkins-scripts.git</url>
      </hudson.plugins.git.UserRemoteConfig>
    </userRemoteConfigs>
    <branches>
      <hudson.plugins.git.BranchSpec>
        <name>$scripts_branch</name>
      </hudson.plugins.git.BranchSpec>
    </branches>
    <disableSubmodules>false</disableSubmodules>
    <recursiveSubmodules>false</recursiveSubmodules>
    <doGenerateSubmoduleConfigurations>false</doGenerateSubmoduleConfigurations>
    <remotePoll>false</remotePoll>
    <gitTool>Default</gitTool>
    <submoduleCfg class="list"/>
    <reference>/home/tcwg-buildslave/snapshots-ref/jenkins-scripts.git</reference>
    <gitConfigName/>
    <gitConfigEmail/>
    <extensions>
      <hudson.plugins.git.extensions.impl.RelativeTargetDirectory>
        <relativeTargetDir>jenkins-scripts</relativeTargetDir>
      </hudson.plugins.git.extensions.impl.RelativeTargetDirectory>
      <hudson.plugins.git.extensions.impl.CleanBeforeCheckout/>
      <hudson.plugins.git.extensions.impl.CloneOption>
        <shallow>false</shallow>
        <depth>1</depth>
        <reference>/home/tcwg-buildslave/snapshots-ref/jenkins-scripts.git</reference>
      </hudson.plugins.git.extensions.impl.CloneOption>
      <hudson.plugins.git.extensions.impl.PruneStaleBranch/>
    </extensions>
  </scm>
  <builders>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
set -ex
# Delete artifacts now to avoid re-using stale artifacts if
# below docker-run.sh fails to start up a container.
rm -rf artifacts/
mkdir -p artifacts/jenkins

build_name="#$BUILD_NUMBER"
echo "$build_name" &gt; artifacts/jenkins/build-name

git -C jenkins-scripts submodule update --init --remote

if [ "True" = "True" ]; then
  cat &gt;&gt; artifacts/jenkins/run-build.env &lt;&lt;EOF
update_baseline=ignore
EOF
fi

cat &gt;&gt; artifacts/jenkins/run-build.env &lt;&lt;EOF
build_name="$build_name"
EOF
</command>
        <unstableReturn>125</unstableReturn>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex

repo='ssh://tcwg-buildslave@bkp.tcwglab/home/tcwg-buildslave/base-artifacts/tcwg_gnu_embed_check_binutils/master-thumb_m23_soft_eabi.git'
branch='linaro-local/ci/tcwg_gnu_embed_check_binutils/master-thumb_m23_soft_eabi'
git_result=$(git ls-remote --heads "$repo" "refs/heads/$branch")
if [ -d base-artifacts ] &amp;&amp; [ "$git_result" != "" ]; then
  git -C base-artifacts fetch "$repo" "refs/heads/$branch" || true
fi

docker_opts=(
  --distro $distro
  --node_labels "$NODE_LABELS"
)

./jenkins-scripts/start-container-docker.sh --prefix build_ \
  "${docker_opts[@]}" &gt; build_container.sh
source build_container.sh
trap "cleanup_all_containers" EXIT

# Run the build script to fetch base-artifacts/, which are
# required to fetch baseline sources to apply patches to in
# pw-apply.sh below.  This also initializes the build manifest
# with all below settings; we then import this manifest below.
#
# The parameter __finish_after makes the build script stop
# after fetching the baseline and "__" avoids saving this parameter
# in the manifest, so that we don't see this option in the main
# run of the build script below.
build_container_exec \
  ./jenkins-scripts/tcwg_gnu-build.sh \
  %%rr[top_artifacts] artifacts \
  ==rr[ci_project] 'tcwg_gnu_embed_check_binutils' \
  ==rr[ci_config] 'master-thumb_m23_soft_eabi' \
  $extra_build_params \
  --scripts_branch "$scripts_branch" \
  ==rr[mode] "build" \
  ==rr[update_baseline] "$update_baseline" \
  --BUILD_URL "$BUILD_URL" \
  __finish_at reset_artifacts

echo "$rr_stage" &gt; artifacts/rr_stage.txt

cat &gt;&gt; artifacts/jenkins/run-build.env &lt;&lt;EOF
docker_opts=(${docker_opts[@]+$(printf "%q$IFS" "${docker_opts[@]}")})
source build_container.sh
trap "cleanup_all_containers" EXIT
EOF

# Now that we have "trap cleanup_all_containers EXIT" in
# run-build.env we need to reset the trap at the end of every
# step to preserve container[s] for the next step.
trap "" EXIT
</command>
        <unstableReturn>125</unstableReturn>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex

./jenkins-scripts/start-container-docker.sh --prefix precommit_ \
  --task precommit --secondary true "${docker_opts[@]}" \
  &gt; precommit_container.sh
source precommit_container.sh

precommit_container_rsync -az --del \
  jenkins-scripts/ :jenkins-scripts/

branch_opt=()
for c in binutils gcc gdb newlib qemu; do
  eval "g=\$${c}_git"
  case "$g" in
    "pw://"*|"ssh://"*|"https://forge.sourceware.org/gcc/gcc-TEST/pulls/"*)
      # Handle pre-commit testing
      case "$g" in
        "pw://"*)
          build_container_exec \
          ./jenkins-scripts/pw-apply.sh \
          --ci_bot 'tcwg_gnu_embed_check_binutils--master-thumb_m23_soft_eabi' \
          --project "$c" --pw_url "$g" __pw_token "$TCWG_PW_TOKEN" \
          --build_url "$BUILD_URL" \
          --pw_dir artifacts/jenkins/pw \
          &amp;&gt; artifacts/jenkins/pw-apply.log &amp;
          ;;
        "ssh://"*)
          build_container_exec \
          ./jenkins-scripts/precommit-ssh-apply.sh \
          --project "$c" --pw_url "$g" \
          --build_url "$BUILD_URL" \
          --patch_submitter "$notify" \
          --pw_dir artifacts/jenkins/pw \
          &amp;&gt; artifacts/jenkins/precommit-ssh-apply.log &amp;
          ;;
        "https://forge.sourceware.org/gcc/gcc-TEST/pulls/"*)
          build_container_exec \
          ./jenkins-scripts/precommit-forge-apply.sh \
          --ci_bot 'tcwg_gnu_embed_check_binutils--master-thumb_m23_soft_eabi' \
          --project "$c" --pw_url "$g" __forgejo_token "$TCWG_FORGEJO_TOKEN" \
          --branch master \
          --build_url "$BUILD_URL" \
          --patch_submitter "$notify" \
          --pw_dir artifacts/jenkins/pw \
          &amp;&gt; artifacts/jenkins/precommit-forge-apply.log &amp;
          ;;
      esac
      res=0 &amp;&amp; wait $! || res=$?

      if [ "$res" != "0" ]; then
        build_name="$build_name-$g-$c-apply-fail"
        echo "$build_name" &gt; artifacts/jenkins/build-name

        # Notify developer of failure to apply.
        for f in mail-body.txt mail-subject.txt \
          mail-recipients.txt; do
          # copy the file if exists, and not emtpy.
          # this is important for mail-recipient.txt, which may
          # be empty.
          if [ -s artifacts/jenkins/pw/$f ]; then
            cp artifacts/jenkins/pw/$f artifacts/jenkins/$f
          fi
        done

        case "$g" in
          "ssh://"*)
            # Build was triggered manually, so failure-to-apply
            # is a real failure.
            exit 1
            ;;
        esac

        # Skip the build
        exit 125
      fi

      # Check whether we should keep or skip this commit
      build_container_exec \
      ./jenkins-scripts/precommit-keep-or-skip.sh \
      --pw_dir artifacts/jenkins/pw \
      --ci_project 'tcwg_gnu_embed_check_binutils' \
      --ci_config 'master-thumb_m23_soft_eabi' \
      --project "$c" &amp;
      keep=0 &amp;&amp; wait $! || keep=$?

      skip=$(declare -A pw
                 source "artifacts/jenkins/pw/$c"
                 echo "${pw[${c}_skip]}")

      if $skip; then
        build_name="$build_name-$g-$c-test-skip"
        echo "$build_name" &gt; artifacts/jenkins/build-name

        # pw-report.sh does not use artifacts/artifacts.precommit,
        # so it is OK to use unsafe container.
        build_container_exec \
        ./jenkins-scripts/pw-report.sh --pw_dir "artifacts/jenkins/pw" \
        --check test --result skip \
        &amp;&gt; artifacts/jenkins/pw-report.log

        # Skip the build
        exit 125
      fi

      patch_id=$(declare -A pw
                 source "artifacts/jenkins/pw/$c"
                 echo "${pw[${c}_patch_id]}")
      build_name="$build_name-$g/$patch_id"
      g=HEAD
      precommit_container_rsync -az --del \
        "$c/" ":$c/"
    ;;
  esac

  if [ x"$g" != x"baseline" ]; then
    build_name="$build_name-$c"
    branch_opt+=("==rr[${c}_git]" "$g")
  fi
done

# Now that artifacts/ include all necessary data (including
# artifacts/jenkins/pw/ directory -- rsync them into precommit
# container.
precommit_container_rsync -az --del \
  artifacts/ :artifacts/

echo "$build_name" &gt; artifacts/jenkins/build-name

cat &gt;&gt; artifacts/jenkins/run-build.env &lt;&lt;EOF
source precommit_container.sh
build_name="$build_name"
branch_opt=(${branch_opt[@]+$(printf "%q$IFS" "${branch_opt[@]}")})
EOF

trap "" EXIT
</command>
        <unstableReturn>125</unstableReturn>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex

# Run the build script to from the manifest created above.
#
# The parameter __start_at makes the build script start right
# where the above run finished.  This allows us to use read-only
# bind-mount for base-artifacts/, which, otherwise, may require
# multi-gig rsync.
precommit_container_exec \
  ./jenkins-scripts/tcwg_gnu-build.sh \
  @@rr[top_artifacts] artifacts \
  "${branch_opt[@]}" \
  __start_at reset_artifacts+ &amp;
res=0 &amp;&amp; wait $! || res=$?

precommit_container_rsync -az --del \
  :artifacts/ artifacts/artifacts.precommit/
find artifacts/artifacts.precommit -size +1M ! -name "*.xz" \
  -print0 | xargs -0 -P0 -i@ xz -T0 @

# Everything but 0 and $INTERNAL_FAILURE is an unexpected exit code,
# so stop here and do nothing else.  From jenkins point of view ...
# - if $res==0: build is successful, so proceed with all
#   followup steps -- notify, push, trigger precommit.
# - if $res==123: build has a regression, so proceed with triggering
#   followup builds and sending precommit notifications; but stop
#   before run-push-baseline by checking artifacts/failed.
# - if $res is anything else: build has an unexpected failure, so
#   skip the rest of the steps by setting UNSTABLE build status.
#   This will cause all followup conditional-steps to skip due to
#   "current-status" condition.
#
# See comment before round-robin.sh:check_regression() for details.
case $res in
  0)
    pw_result=pass
    ;;
  123)
    echo 123 &gt; artifacts/failed
    pw_result=fail
    ;;
  *)
    res=125
    pw_result=ignore
    ;;
esac

# pw-report.sh does not use artifacts/artifacts.precommit,
# so it is OK to use unsafe container.
build_container_exec \
  ./jenkins-scripts/pw-report.sh --pw_dir "artifacts/jenkins/pw" \
  --check test --result "$pw_result"
  &amp;&gt; artifacts/jenkins/pw-report.log &amp;
if ! wait $!; then
  res=125
fi

if [ $res = 125 ]; then
  # We had unexpected failure in the build scripts, so can't
  # proceed with triggers and notifications.  Mark this build
  # as UNSTABLE, which will skip all following conditional-steps.
  exit 125
fi

cat &gt;&gt; artifacts/jenkins/run-build.env &lt;&lt;EOF
build_name="$build_name"
EOF

trap "" EXIT
</command>
        <unstableReturn>125</unstableReturn>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex

precommit_container_exec \
  ./jenkins-scripts/rr/round-robin-notify.sh \
  @@rr[top_artifacts] artifacts --notify "$notify" \
  --pw_dir artifacts/jenkins/pw __verbose true \
  __build_script tcwg_gnu-build.sh \
  &amp;&gt; ./artifacts/jenkins/notify.log &amp;

if ! wait $!; then
  echo "maxim.kuvyrkov@linaro.org, laurent.alfonsi@linaro.org" \
    &gt; artifacts/jenkins/error-mail-recipients.txt
  echo -e "$BUILD_URL\nERROR: notify failed\n" \
    &gt;&gt; artifacts/jenkins/error-mail-body.txt
  echo "ERROR: notify failed"
  exit 1
fi

precommit_container_rsync -az --del \
  :artifacts/ artifacts/artifacts.precommit/
# Compress big files in artifacts.precommit/ to save disk space
# on ci.linaro.org.  We keep all pre-commit builds for a month,
# which can result in many stored builds.
find artifacts/artifacts.precommit -size +1M ! -name "*.xz" \
  ! -path "artifacts/artifacts.precommit/notify/*" \
  ! -path "artifacts/artifacts.precommit/jenkins/*" -print0 \
  | xargs -0 -P0 -i@ xz -T0 @

for f in mail-body.txt mail-subject.txt mail-recipients.txt; do
  # copy the file if exists, and not emtpy.
  # this is important for mail-recipient.txt, which may be empty.
  if [ -s artifacts/artifacts.precommit/jenkins/$f ]; then
    cp artifacts/artifacts.precommit/jenkins/$f artifacts/jenkins/$f
  fi
done

# Post the results to the forge if applicable.
# pw-report.sh does not use artifacts/artifacts.precommit,
# so it is OK to use unsafe container.
if [ -f artifacts/failed ]; then
  pw_result=fail
else
  pw_result=pass
fi
build_container_exec \
  ./jenkins-scripts/pw-report.sh --pw_dir "artifacts/jenkins/pw" \
  --check test --result postforge-"$pw_result" \
  &amp;&gt; artifacts/jenkins/pw-report.log &amp;
if ! wait $!; then
  echo "maxim.kuvyrkov@linaro.org, laurent.alfonsi@linaro.org" \
    &gt; artifacts/jenkins/error-mail-recipients.txt
  echo -e "$BUILD_URL\nERROR: notify failed\n" \
    &gt;&gt; artifacts/jenkins/error-mail-body.txt
  echo "ERROR: forge notify failed"
  exit 1
fi

trap "" EXIT
</command>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex

if [ -f artifacts/failed ]; then
  # Mark failed build as FAILURE; no further steps will run.
  exit $(cat artifacts/failed)
fi
# Only successful builds run beyond this point.

trap "" EXIT
</command>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
    <org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
      <buildName>artifacts/jenkins/build-name</buildName>
      <macroTemplate>#${BUILD_NUMBER}</macroTemplate>
      <fromFile>true</fromFile>
      <fromMacro>false</fromMacro>
      <macroFirst>false</macroFirst>
    </org.jenkinsci.plugins.buildnameupdater.BuildNameUpdater>
    <org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
      <condition class="org.jenkins_ci.plugins.run_condition.core.StatusCondition">
        <worstResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </worstResult>
        <bestResult>
          <name>SUCCESS</name>
          <ordinal>0</ordinal>
          <color>BLUE</color>
          <completeBuild>true</completeBuild>
        </bestResult>
      </condition>
      <runner class="org.jenkins_ci.plugins.run_condition.BuildStepRunner$Fail"/>
      <buildStep class="hudson.tasks.Shell">
        <command>#!/bin/bash
source artifacts/jenkins/run-build.env
set -ex
# The "trap cleanup_all_containers EXIT" statement in
# artifacts/jenkins/run-build.env will remove build and precommit
# containers.
</command>
        <unstableReturn>0</unstableReturn>
      </buildStep>
    </org.jenkinsci.plugins.conditionalbuildstep.singlestep.SingleConditionalBuilder>
  </builders>
  <publishers>
    <hudson.tasks.ArtifactArchiver>
      <artifacts>artifacts/**</artifacts>
      <allowEmptyArchive>false</allowEmptyArchive>
      <onlyIfSuccessful>false</onlyIfSuccessful>
      <fingerprint>false</fingerprint>
      <defaultExcludes>true</defaultExcludes>
      <caseSensitive>true</caseSensitive>
      <latestOnly>false</latestOnly>
    </hudson.tasks.ArtifactArchiver>
    <hudson.plugins.emailext.ExtendedEmailPublisher>
      <recipientList>${FILE,path="artifacts/jenkins/mail-recipients.txt"}
</recipientList>
      <configuredTriggers>
        <hudson.plugins.emailext.plugins.trigger.FailureTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.FailureTrigger>
        <hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
      </configuredTriggers>
      <contentType>text/plain</contentType>
      <defaultSubject>${FILE,path="artifacts/jenkins/mail-subject.txt"}
</defaultSubject>
      <defaultContent>${FILE,path="artifacts/jenkins/mail-body.txt"}
</defaultContent>
      <attachmentsPattern/>
      <presendScript/>
      <postsendScript/>
      <attachBuildLog>false</attachBuildLog>
      <compressBuildLog>false</compressBuildLog>
      <saveOutput>false</saveOutput>
      <disabled>false</disabled>
      <replyTo>linaro-toolchain@lists.linaro.org</replyTo>
    </hudson.plugins.emailext.ExtendedEmailPublisher>
    <hudson.plugins.emailext.ExtendedEmailPublisher>
      <recipientList>${FILE,path="artifacts/jenkins/error-mail-recipients.txt"}
</recipientList>
      <configuredTriggers>
        <hudson.plugins.emailext.plugins.trigger.AbortedTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.AbortedTrigger>
        <hudson.plugins.emailext.plugins.trigger.FailureTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.FailureTrigger>
        <hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
      </configuredTriggers>
      <contentType>default</contentType>
      <defaultSubject>$DEFAULT_SUBJECT</defaultSubject>
      <defaultContent>${FILE,path="artifacts/jenkins/error-mail-body.txt"}
</defaultContent>
      <attachmentsPattern/>
      <presendScript/>
      <postsendScript/>
      <attachBuildLog>false</attachBuildLog>
      <compressBuildLog>false</compressBuildLog>
      <saveOutput>false</saveOutput>
      <disabled>false</disabled>
      <replyTo>$DEFAULT_REPLYTO</replyTo>
    </hudson.plugins.emailext.ExtendedEmailPublisher>
    <hudson.plugins.emailext.ExtendedEmailPublisher>
      <recipientList>${FILE,path="artifacts/jenkins/testresults-mail-recipients.txt"}
</recipientList>
      <configuredTriggers>
        <hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
          <email>
            <recipientList/>
            <subject>$PROJECT_DEFAULT_SUBJECT</subject>
            <body>$PROJECT_DEFAULT_CONTENT</body>
            <sendToDevelopers>false</sendToDevelopers>
            <sendToRequester>false</sendToRequester>
            <includeCulprits>false</includeCulprits>
            <sendToRecipientList>true</sendToRecipientList>
          </email>
        </hudson.plugins.emailext.plugins.trigger.SuccessTrigger>
      </configuredTriggers>
      <contentType>text/plain</contentType>
      <defaultSubject>${FILE,path="artifacts/jenkins/testresults-mail-subject.txt"}
</defaultSubject>
      <defaultContent>${FILE,path="artifacts/jenkins/testresults-mail-body.txt"}
</defaultContent>
      <attachmentsPattern/>
      <presendScript/>
      <postsendScript/>
      <attachBuildLog>false</attachBuildLog>
      <compressBuildLog>false</compressBuildLog>
      <saveOutput>false</saveOutput>
      <disabled>false</disabled>
      <replyTo>linaro-toolchain@lists.linaro.org</replyTo>
    </hudson.plugins.emailext.ExtendedEmailPublisher>
  </publishers>
  <buildWrappers>
    <hudson.plugins.build__timeout.BuildTimeoutWrapper>
      <strategy class="hudson.plugins.build_timeout.impl.AbsoluteTimeOutStrategy">
        <timeoutMinutes>1000</timeoutMinutes>
      </strategy>
      <operationList>
        <hudson.plugins.build__timeout.operations.AbortOperation/>
      </operationList>
    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
    <hudson.plugins.timestamper.TimestamperBuildWrapper/>
    <com.cloudbees.jenkins.plugins.sshagent.SSHAgentBuildWrapper>
      <credentialIds>
        <string>e0958a95-204f-4c14-a66c-5e2be6c5d50a</string>
        <string>tcwg-buildslave-20220725</string>
        <ignoreMissing>false</ignoreMissing>
      </credentialIds>
    </com.cloudbees.jenkins.plugins.sshagent.SSHAgentBuildWrapper>
    <org.jenkinsci.plugins.credentialsbinding.impl.SecretBuildWrapper>
      <bindings>
        <org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
          <variable>TCWG_JIRA_TOKEN</variable>
          <credentialsId>TCWG_JIRA_TOKEN</credentialsId>
        </org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
        <org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
          <variable>TCWG_PW_TOKEN</variable>
          <credentialsId>TCWG_PW_TOKEN</credentialsId>
        </org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
        <org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
          <variable>TCWG_FORGEJO_TOKEN</variable>
          <credentialsId>TCWG_FORGEJO_TOKEN</credentialsId>
        </org.jenkinsci.plugins.credentialsbinding.impl.StringBinding>
      </bindings>
    </org.jenkinsci.plugins.credentialsbinding.impl.SecretBuildWrapper>
  </buildWrappers>
</project>