dev-support/Jenkinsfile

   1 // Licensed to the Apache Software Foundation (ASF) under one
   2 // or more contributor license agreements.  See the NOTICE file
   3 // distributed with this work for additional information
   4 // regarding copyright ownership.  The ASF licenses this file
   5 // to you under the Apache License, Version 2.0 (the
   6 // "License"); you may not use this file except in compliance
   7 // with the License.  You may obtain a copy of the License at
   8 //
   9 //   http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing,
  12 // software distributed under the License is distributed on an
  13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 // KIND, either express or implied.  See the License for the
  15 // specific language governing permissions and limitations
  16 // under the License.
  17 pipeline {
  18   agent {
  19     node {
  20       label 'Hadoop'
  21     }
  22   }
  23   triggers {
  24     cron('@daily')
  25   }
  26   options {
  27     buildDiscarder(logRotator(numToKeepStr: '15'))
  28     timeout (time: 9, unit: 'HOURS')
  29     timestamps()
  30     skipDefaultCheckout()
  31     disableConcurrentBuilds()
  32   }
  33   environment {
  34     YETUS_RELEASE = '0.11.1'
  35     // where we'll write everything from different steps. Need a copy here so the final step can check for success/failure.
  36     OUTPUT_DIR_RELATIVE_GENERAL = 'output-general'
  37     OUTPUT_DIR_RELATIVE_JDK7 = 'output-jdk7'
  38     OUTPUT_DIR_RELATIVE_JDK8_HADOOP2 = 'output-jdk8-hadoop2'
  39     OUTPUT_DIR_RELATIVE_JDK8_HADOOP3 = 'output-jdk8-hadoop3'
  40     OUTPUT_DIR_RELATIVE_JDK11_HADOOP3 = 'output-jdk11-hadoop3'
  41
  42     PROJECT = 'hbase'
  43     PROJECT_PERSONALITY = 'https://raw.githubusercontent.com/apache/hbase/master/dev-support/hbase-personality.sh'
  44     PERSONALITY_FILE = 'tools/personality.sh'
  45     // This section of the docs tells folks not to use the javadoc tag. older branches have our old version of the check for said tag.
  46     AUTHOR_IGNORE_LIST = 'src/main/asciidoc/_chapters/developer.adoc,dev-support/test-patch.sh'
  47     WHITESPACE_IGNORE_LIST = '.*/generated/.*'
  48     // output from surefire; sadly the archive function in yetus only works on file names.
  49     ARCHIVE_PATTERN_LIST = 'TEST-*.xml,org.apache.h*.txt,*.dumpstream,*.dump'
  50     // These tests currently have known failures. Once they burn down to 0, remove from here so that new problems will cause a failure.
  51     TESTS_FILTER = 'cc,checkstyle,javac,javadoc,pylint,shellcheck,whitespace,perlcritic,ruby-lint,rubocop,mvnsite'
  52     EXCLUDE_TESTS_URL = "${JENKINS_URL}/job/HBase-Find-Flaky-Tests/job/${BRANCH_NAME}/lastSuccessfulBuild/artifact/excludes"
  53       // TODO does hadoopcheck need to be jdk specific?
  54     SHALLOW_CHECKS = 'all,-shadedjars,-unit' // run by the 'yetus general check'
  55     DEEP_CHECKS = 'compile,htmlout,javac,maven,mvninstall,shadedjars,unit' // run by 'yetus jdkX (HadoopY) checks'
  56   }
  57   parameters {
  58     booleanParam(name: 'USE_YETUS_PRERELEASE', defaultValue: false, description: '''Check to use the current HEAD of apache/yetus rather than our configured release.
  59
  60     Should only be used manually when e.g. there is some non-work-aroundable issue in yetus we are checking a fix for.''')
  61     booleanParam(name: 'DEBUG', defaultValue: false, description: 'Produce a lot more meta-information.')
  62   }
  63   stages {
  64     stage ('scm-checkout') {
  65       steps {
  66             dir('component') {
  67               checkout scm
  68             }
  69       }
  70     }
  71     stage ('thirdparty installs') {
  72       parallel {
  73         stage ('yetus install') {
  74           steps {
  75             // directory must be unique for each parallel stage, because jenkins runs them in the same workspace :(
  76             dir('downloads-yetus') {
  77               // can't just do a simple echo or the directory won't be created. :(
  78               sh '''#!/usr/bin/env bash
  79                 echo "Make sure we have a directory for downloading dependencies: $(pwd)"
  80 '''
  81             }
  82             sh  '''#!/usr/bin/env bash
  83               set -e
  84               echo "Ensure we have a copy of Apache Yetus."
  85               if [[ true !=  "${USE_YETUS_PRERELEASE}" ]]; then
  86                 YETUS_DIR="${WORKSPACE}/yetus-${YETUS_RELEASE}"
  87                 echo "Checking for Yetus ${YETUS_RELEASE} in '${YETUS_DIR}'"
  88                 if ! "${YETUS_DIR}/bin/test-patch" --version >/dev/null 2>&1 ; then
  89                   rm -rf "${YETUS_DIR}"
  90                   "${WORKSPACE}/component/dev-support/jenkins-scripts/cache-apache-project-artifact.sh" \
  91                       --working-dir "${WORKSPACE}/downloads-yetus" \
  92                       --keys 'https://www.apache.org/dist/yetus/KEYS' \
  93                       "${WORKSPACE}/yetus-${YETUS_RELEASE}-bin.tar.gz" \
  94                       "yetus/${YETUS_RELEASE}/apache-yetus-${YETUS_RELEASE}-bin.tar.gz"
  95                   mv "yetus-${YETUS_RELEASE}-bin.tar.gz" yetus.tar.gz
  96                 else
  97                   echo "Reusing cached install of Apache Yetus version ${YETUS_RELEASE}."
  98                 fi
  99               else
 100                 YETUS_DIR="${WORKSPACE}/yetus-git"
 101                 rm -rf "${YETUS_DIR}"
 102                 echo "downloading from github"
 103                 curl -L --fail https://api.github.com/repos/apache/yetus/tarball/HEAD -o yetus.tar.gz
 104               fi
 105               if [ ! -d "${YETUS_DIR}" ]; then
 106                 echo "unpacking yetus into '${YETUS_DIR}'"
 107                 mkdir -p "${YETUS_DIR}"
 108                 gunzip -c yetus.tar.gz | tar xpf - -C "${YETUS_DIR}" --strip-components 1
 109               fi
 110             '''
 111             // Set up the file we need at PERSONALITY_FILE location
 112             dir ("tools") {
 113               sh """#!/usr/bin/env bash
 114                 set -e
 115                 echo "Downloading Project personality from ${env.PROJECT_PERSONALITY}"
 116                 curl -L  -o personality.sh "${env.PROJECT_PERSONALITY}"
 117               """
 118             }
 119             stash name: 'yetus', includes: "yetus-*/*,yetus-*/**/*,tools/personality.sh"
 120           }
 121         }
 122         stage ('hadoop 2 cache') {
 123           environment {
 124             HADOOP2_VERSION="2.8.5"
 125           }
 126           steps {
 127             // directory must be unique for each parallel stage, because jenkins runs them in the same workspace :(
 128             dir('downloads-hadoop-2') {
 129               sh '''#!/usr/bin/env bash
 130                 echo "Make sure we have a directory for downloading dependencies: $(pwd)"
 131 '''
 132             }
 133             sh '''#!/usr/bin/env bash
 134               set -e
 135               echo "Ensure we have a copy of Hadoop ${HADOOP2_VERSION}"
 136               "${WORKSPACE}/component/dev-support/jenkins-scripts/cache-apache-project-artifact.sh" \
 137                   --working-dir "${WORKSPACE}/downloads-hadoop-2" \
 138                   --keys 'http://www.apache.org/dist/hadoop/common/KEYS' \
 139                   "${WORKSPACE}/hadoop-${HADOOP2_VERSION}-bin.tar.gz" \
 140                   "hadoop/common/hadoop-${HADOOP2_VERSION}/hadoop-${HADOOP2_VERSION}.tar.gz"
 141               for stale in $(ls -1 "${WORKSPACE}"/hadoop-2*.tar.gz | grep -v ${HADOOP2_VERSION}); do
 142                 echo "Delete stale hadoop 2 cache ${stale}"
 143                 rm -rf $stale
 144               done
 145             '''
 146             stash name: 'hadoop-2', includes: "hadoop-${HADOOP2_VERSION}-bin.tar.gz"
 147           }
 148         }
 149         stage ('hadoop 3 cache') {
 150           environment {
 151             HADOOP3_VERSION="3.1.1"
 152           }
 153           steps {
 154             // directory must be unique for each parallel stage, because jenkins runs them in the same workspace :(
 155             dir('downloads-hadoop-3') {
 156               sh '''#!/usr/bin/env bash
 157                 echo "Make sure we have a directory for downloading dependencies: $(pwd)"
 158 '''
 159             }
 160             sh '''#!/usr/bin/env bash
 161               set -e
 162               echo "Ensure we have a copy of Hadoop ${HADOOP3_VERSION}"
 163               "${WORKSPACE}/component/dev-support/jenkins-scripts/cache-apache-project-artifact.sh" \
 164                   --working-dir "${WORKSPACE}/downloads-hadoop-3" \
 165                   --keys 'http://www.apache.org/dist/hadoop/common/KEYS' \
 166                   "${WORKSPACE}/hadoop-${HADOOP3_VERSION}-bin.tar.gz" \
 167                   "hadoop/common/hadoop-${HADOOP3_VERSION}/hadoop-${HADOOP3_VERSION}.tar.gz"
 168               for stale in $(ls -1 "${WORKSPACE}"/hadoop-3*.tar.gz | grep -v ${HADOOP3_VERSION}); do
 169                 echo "Delete stale hadoop 3 cache ${stale}"
 170                 rm -rf $stale
 171               done
 172             '''
 173             stash name: 'hadoop-3', includes: "hadoop-${HADOOP3_VERSION}-bin.tar.gz"
 174           }
 175         }
 176       }
 177     }
 178     stage ('init health results') {
 179       steps {
 180         // stash with given name for all tests we might run, so that we can unstash all of them even if
 181         // we skip some due to e.g. branch-specific JDK or Hadoop support
 182         stash name: 'general-result', allowEmpty: true, includes: "${OUTPUT_DIR_RELATIVE_GENERAL}/doesn't-match"
 183         stash name: 'jdk7-result', allowEmpty: true, includes: "${OUTPUT_DIR_RELATIVE_JDK7}/doesn't-match"
 184         stash name: 'jdk8-hadoop2-result', allowEmpty: true, includes: "${OUTPUT_DIR_RELATIVE_JDK8_HADOOP2}/doesn't-match"
 185         stash name: 'jdk8-hadoop3-result', allowEmpty: true, includes: "${OUTPUT_DIR_RELATIVE_JDK8_HADOOP3}/doesn't-match"
 186         stash name: 'jdk11-hadoop3-result', allowEmpty: true, includes: "${OUTPUT_DIR_RELATIVE_JDK11_HADOOP3}/doesn't-match"
 187         stash name: 'srctarball-result', allowEmpty: true, includes: "output-srctarball/doesn't-match"
 188       }
 189     }
 190     stage ('health checks') {
 191       parallel {
 192         stage ('yetus general check') {
 193           agent {
 194             node {
 195               label 'Hadoop'
 196             }
 197           }
 198           environment {
 199             BASEDIR = "${env.WORKSPACE}/component"
 200             TESTS = "${env.SHALLOW_CHECKS}"
 201             SET_JAVA_HOME = '/usr/lib/jvm/java-8'
 202             OUTPUT_DIR_RELATIVE = "${env.OUTPUT_DIR_RELATIVE_GENERAL}"
 203             OUTPUT_DIR = "${env.WORKSPACE}/${env.OUTPUT_DIR_RELATIVE_GENERAL}"
 204           }
 205           steps {
 206             // Must do prior to anything else, since if one of them timesout we'll stash the commentfile
 207             sh '''#!/usr/bin/env bash
 208               set -e
 209               rm -rf "${OUTPUT_DIR}" && mkdir "${OUTPUT_DIR}"
 210               echo '(x) {color:red}-1 general checks{color}' >"${OUTPUT_DIR}/commentfile"
 211               echo "-- Something went wrong running this stage, please [check relevant console output|${BUILD_URL}/console]." >> "${OUTPUT_DIR}/commentfile"
 212 '''
 213             unstash 'yetus'
 214             // since we have a new node definition we need to re-do the scm checkout
 215             dir('component') {
 216               checkout scm
 217             }
 218             sh '''#!/usr/bin/env bash
 219               set -e
 220               rm -rf "${OUTPUT_DIR}/machine" && mkdir "${OUTPUT_DIR}/machine"
 221               "${BASEDIR}/dev-support/gather_machine_environment.sh" "${OUTPUT_DIR_RELATIVE}/machine"
 222               echo "got the following saved stats in '${OUTPUT_DIR_RELATIVE}/machine'"
 223               ls -lh "${OUTPUT_DIR_RELATIVE}/machine"
 224 '''
 225             // TODO roll this into the hbase_nightly_yetus script
 226             sh '''#!/usr/bin/env bash
 227               set -e
 228               declare -i status=0
 229               if "${BASEDIR}/dev-support/hbase_nightly_yetus.sh" ; then
 230                 echo '(/) {color:green}+1 general checks{color}' > "${OUTPUT_DIR}/commentfile"
 231               else
 232                 echo '(x) {color:red}-1 general checks{color}' > "${OUTPUT_DIR}/commentfile"
 233                 status=1
 234               fi
 235               echo "-- For more information [see general report|${BUILD_URL}/General_Nightly_Build_Report/]" >> "${OUTPUT_DIR}/commentfile"
 236               exit "${status}"
 237             '''
 238           }
 239           post {
 240             always {
 241               stash name: 'general-result', includes: "${OUTPUT_DIR_RELATIVE}/commentfile"
 242               // Has to be relative to WORKSPACE.
 243               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/*"
 244               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/**/*"
 245               publishHTML target: [
 246                 allowMissing: true,
 247                 keepAll: true,
 248                 alwaysLinkToLastBuild: true,
 249                 // Has to be relative to WORKSPACE
 250                 reportDir: "${env.OUTPUT_DIR_RELATIVE}",
 251                 reportFiles: 'console-report.html',
 252                 reportName: 'General Nightly Build Report'
 253               ]
 254             }
 255           }
 256         }
 257         stage ('yetus jdk7 checks') {
 258           agent {
 259             node {
 260               label 'Hadoop'
 261             }
 262           }
 263           when {
 264             branch 'branch-1*'
 265           }
 266           environment {
 267             BASEDIR = "${env.WORKSPACE}/component"
 268             TESTS = "${env.DEEP_CHECKS}"
 269             OUTPUT_DIR_RELATIVE = "${env.OUTPUT_DIR_RELATIVE_JDK7}"
 270             OUTPUT_DIR = "${env.WORKSPACE}/${env.OUTPUT_DIR_RELATIVE_JDK7}"
 271             SET_JAVA_HOME = "/usr/lib/jvm/java-7"
 272           }
 273           steps {
 274             // Must do prior to anything else, since if one of them timesout we'll stash the commentfile
 275             sh '''#!/usr/bin/env bash
 276               set -e
 277               rm -rf "${OUTPUT_DIR}" && mkdir "${OUTPUT_DIR}"
 278               echo '(x) {color:red}-1 jdk7 checks{color}' >"${OUTPUT_DIR}/commentfile"
 279               echo "-- Something went wrong running this stage, please [check relevant console output|${BUILD_URL}/console]." >> "${OUTPUT_DIR}/commentfile"
 280 '''
 281             unstash 'yetus'
 282             dir('component') {
 283               checkout scm
 284             }
 285             sh '''#!/usr/bin/env bash
 286               set -e
 287               rm -rf "${OUTPUT_DIR}/machine" && mkdir "${OUTPUT_DIR}/machine"
 288               "${BASEDIR}/dev-support/gather_machine_environment.sh" "${OUTPUT_DIR_RELATIVE}/machine"
 289               echo "got the following saved stats in '${OUTPUT_DIR_RELATIVE}/machine'"
 290               ls -lh "${OUTPUT_DIR_RELATIVE}/machine"
 291 '''
 292             sh '''#!/usr/bin/env bash
 293               set -e
 294               declare -i status=0
 295               if "${BASEDIR}/dev-support/hbase_nightly_yetus.sh" ; then
 296                 echo '(/) {color:green}+1 jdk7 checks{color}' > "${OUTPUT_DIR}/commentfile"
 297               else
 298                 echo '(x) {color:red}-1 jdk7 checks{color}' > "${OUTPUT_DIR}/commentfile"
 299                 status=1
 300               fi
 301               echo "-- For more information [see jdk7 report|${BUILD_URL}/JDK7_Nightly_Build_Report/]" >> "${OUTPUT_DIR}/commentfile"
 302               exit "${status}"
 303             '''
 304           }
 305           post {
 306             always {
 307               stash name: 'jdk7-result', includes: "${OUTPUT_DIR_RELATIVE}/commentfile"
 308               junit testResults: "${env.OUTPUT_DIR_RELATIVE}/**/target/**/TEST-*.xml", allowEmptyResults: true
 309               // zip surefire reports.
 310               sh '''#!/bin/bash -e
 311                 if [ -d "${OUTPUT_DIR}/archiver" ]; then
 312                   count=$(find "${OUTPUT_DIR}/archiver" -type f | wc -l)
 313                   if [[ 0 -ne ${count} ]]; then
 314                     echo "zipping ${count} archived files"
 315                     zip -q -m -r "${OUTPUT_DIR}/test_logs.zip" "${OUTPUT_DIR}/archiver"
 316                   else
 317                     echo "No archived files, skipping compressing."
 318                   fi
 319                 else
 320                   echo "No archiver directory, skipping compressing."
 321                 fi
 322 '''
 323               // Has to be relative to WORKSPACE.
 324               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/*"
 325               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/**/*"
 326               publishHTML target: [
 327                 allowMissing         : true,
 328                 keepAll              : true,
 329                 alwaysLinkToLastBuild: true,
 330                 // Has to be relative to WORKSPACE.
 331                 reportDir            : "${env.OUTPUT_DIR_RELATIVE}",
 332                 reportFiles          : 'console-report.html',
 333                 reportName           : 'JDK7 Nightly Build Report'
 334               ]
 335             }
 336           }
 337         }
 338         stage ('yetus jdk8 hadoop2 checks') {
 339           agent {
 340             node {
 341               label 'Hadoop'
 342             }
 343           }
 344           environment {
 345             BASEDIR = "${env.WORKSPACE}/component"
 346             TESTS = "${env.DEEP_CHECKS}"
 347             OUTPUT_DIR_RELATIVE = "${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP2}"
 348             OUTPUT_DIR = "${env.WORKSPACE}/${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP2}"
 349             SET_JAVA_HOME = '/usr/lib/jvm/java-8'
 350           }
 351           steps {
 352             // Must do prior to anything else, since if one of them timesout we'll stash the commentfile
 353             sh '''#!/usr/bin/env bash
 354               set -e
 355               rm -rf "${OUTPUT_DIR}" && mkdir "${OUTPUT_DIR}"
 356               echo '(x) {color:red}-1 jdk8 hadoop2 checks{color}' >"${OUTPUT_DIR}/commentfile"
 357               echo "-- Something went wrong running this stage, please [check relevant console output|${BUILD_URL}/console]." >> "${OUTPUT_DIR}/commentfile"
 358 '''
 359             unstash 'yetus'
 360             dir('component') {
 361               checkout scm
 362             }
 363             sh '''#!/usr/bin/env bash
 364               set -e
 365               rm -rf "${OUTPUT_DIR}/machine" && mkdir "${OUTPUT_DIR}/machine"
 366               "${BASEDIR}/dev-support/gather_machine_environment.sh" "${OUTPUT_DIR_RELATIVE}/machine"
 367               echo "got the following saved stats in '${OUTPUT_DIR_RELATIVE}/machine'"
 368               ls -lh "${OUTPUT_DIR_RELATIVE}/machine"
 369 '''
 370             sh '''#!/usr/bin/env bash
 371               set -e
 372               declare -i status=0
 373               if "${BASEDIR}/dev-support/hbase_nightly_yetus.sh" ; then
 374                 echo '(/) {color:green}+1 jdk8 hadoop2 checks{color}' > "${OUTPUT_DIR}/commentfile"
 375               else
 376                 echo '(x) {color:red}-1 jdk8 hadoop2 checks{color}' > "${OUTPUT_DIR}/commentfile"
 377                 status=1
 378               fi
 379               echo "-- For more information [see jdk8 (hadoop2) report|${BUILD_URL}/JDK8_Nightly_Build_Report_(Hadoop2)/]" >> "${OUTPUT_DIR}/commentfile"
 380               exit "${status}"
 381             '''
 382           }
 383           post {
 384             always {
 385               stash name: 'jdk8-hadoop2-result', includes: "${OUTPUT_DIR_RELATIVE}/commentfile"
 386               junit testResults: "${env.OUTPUT_DIR_RELATIVE}/**/target/**/TEST-*.xml", allowEmptyResults: true
 387               // zip surefire reports.
 388               sh '''#!/bin/bash -e
 389                 if [ -d "${OUTPUT_DIR}/archiver" ]; then
 390                   count=$(find "${OUTPUT_DIR}/archiver" -type f | wc -l)
 391                   if [[ 0 -ne ${count} ]]; then
 392                     echo "zipping ${count} archived files"
 393                     zip -q -m -r "${OUTPUT_DIR}/test_logs.zip" "${OUTPUT_DIR}/archiver"
 394                   else
 395                     echo "No archived files, skipping compressing."
 396                   fi
 397                 else
 398                   echo "No archiver directory, skipping compressing."
 399                 fi
 400 '''
 401               // Has to be relative to WORKSPACE.
 402               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/*"
 403               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/**/*"
 404               publishHTML target: [
 405                 allowMissing         : true,
 406                 keepAll              : true,
 407                 alwaysLinkToLastBuild: true,
 408                 // Has to be relative to WORKSPACE.
 409                 reportDir            : "${env.OUTPUT_DIR_RELATIVE}",
 410                 reportFiles          : 'console-report.html',
 411                 reportName           : 'JDK8 Nightly Build Report (Hadoop2)'
 412               ]
 413             }
 414           }
 415         }
 416         stage ('yetus jdk8 hadoop3 checks') {
 417           agent {
 418             node {
 419               label 'Hadoop'
 420             }
 421           }
 422           when {
 423             not {
 424               branch 'branch-1*'
 425             }
 426           }
 427           environment {
 428             BASEDIR = "${env.WORKSPACE}/component"
 429             TESTS = "${env.DEEP_CHECKS}"
 430             OUTPUT_DIR_RELATIVE = "${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP3}"
 431             OUTPUT_DIR = "${env.WORKSPACE}/${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP3}"
 432             SET_JAVA_HOME = '/usr/lib/jvm/java-8'
 433             // Activates hadoop 3.0 profile in maven runs.
 434             HADOOP_PROFILE = '3.0'
 435           }
 436           steps {
 437             // Must do prior to anything else, since if one of them timesout we'll stash the commentfile
 438             sh '''#!/usr/bin/env bash
 439               set -e
 440               rm -rf "${OUTPUT_DIR}" && mkdir "${OUTPUT_DIR}"
 441               echo '(x) {color:red}-1 jdk8 hadoop3 checks{color}' >"${OUTPUT_DIR}/commentfile"
 442               echo "-- Something went wrong running this stage, please [check relevant console output|${BUILD_URL}/console]." >> "${OUTPUT_DIR}/commentfile"
 443 '''
 444             unstash 'yetus'
 445             dir('component') {
 446               checkout scm
 447             }
 448             sh '''#!/usr/bin/env bash
 449               set -e
 450               rm -rf "${OUTPUT_DIR}/machine" && mkdir "${OUTPUT_DIR}/machine"
 451               "${BASEDIR}/dev-support/gather_machine_environment.sh" "${OUTPUT_DIR_RELATIVE}/machine"
 452               echo "got the following saved stats in '${OUTPUT_DIR_RELATIVE}/machine'"
 453               ls -lh "${OUTPUT_DIR_RELATIVE}/machine"
 454 '''
 455             sh '''#!/usr/bin/env bash
 456               set -e
 457               declare -i status=0
 458               if "${BASEDIR}/dev-support/hbase_nightly_yetus.sh" ; then
 459                 echo '(/) {color:green}+1 jdk8 hadoop3 checks{color}' > "${OUTPUT_DIR}/commentfile"
 460               else
 461                 echo '(x) {color:red}-1 jdk8 hadoop3 checks{color}' > "${OUTPUT_DIR}/commentfile"
 462                 status=1
 463               fi
 464               echo "-- For more information [see jdk8 (hadoop3) report|${BUILD_URL}/JDK8_Nightly_Build_Report_(Hadoop3)/]" >> "${OUTPUT_DIR}/commentfile"
 465               exit "${status}"
 466             '''
 467           }
 468           post {
 469             always {
 470               stash name: 'jdk8-hadoop3-result', includes: "${OUTPUT_DIR_RELATIVE}/commentfile"
 471               junit testResults: "${env.OUTPUT_DIR_RELATIVE}/**/target/**/TEST-*.xml", allowEmptyResults: true
 472               // zip surefire reports.
 473               sh '''#!/bin/bash -e
 474                 if [ -d "${OUTPUT_DIR}/archiver" ]; then
 475                   count=$(find "${OUTPUT_DIR}/archiver" -type f | wc -l)
 476                   if [[ 0 -ne ${count} ]]; then
 477                     echo "zipping ${count} archived files"
 478                     zip -q -m -r "${OUTPUT_DIR}/test_logs.zip" "${OUTPUT_DIR}/archiver"
 479                   else
 480                     echo "No archived files, skipping compressing."
 481                   fi
 482                 else
 483                   echo "No archiver directory, skipping compressing."
 484                 fi
 485 '''
 486               // Has to be relative to WORKSPACE.
 487               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/*"
 488               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/**/*"
 489               publishHTML target: [
 490                 allowMissing         : true,
 491                 keepAll              : true,
 492                 alwaysLinkToLastBuild: true,
 493                 // Has to be relative to WORKSPACE.
 494                 reportDir            : "${env.OUTPUT_DIR_RELATIVE}",
 495                 reportFiles          : 'console-report.html',
 496                 reportName           : 'JDK8 Nightly Build Report (Hadoop3)'
 497               ]
 498             }
 499           }
 500         }
 501         stage ('yetus jdk11 hadoop3 checks') {
 502           agent {
 503             node {
 504               label 'Hadoop'
 505             }
 506           }
 507           when {
 508             not {
 509               branch 'branch-1*'
 510             }
 511           }
 512           environment {
 513             BASEDIR = "${env.WORKSPACE}/component"
 514             TESTS = "${env.DEEP_CHECKS}"
 515             OUTPUT_DIR_RELATIVE = "${env.OUTPUT_DIR_RELATIVE_JDK11_HADOOP3}"
 516             OUTPUT_DIR = "${env.WORKSPACE}/${env.OUTPUT_DIR_RELATIVE_JDK11_HADOOP3}"
 517             SET_JAVA_HOME = "/usr/lib/jvm/java-11"
 518             // Activates hadoop 3.0 profile in maven runs.
 519             HADOOP_PROFILE = '3.0'
 520             // ErrorProne is broken on JDK11, see HBASE-23894
 521             SKIP_ERROR_PRONE = 'true'
 522           }
 523           steps {
 524             // Must do prior to anything else, since if one of them timesout we'll stash the commentfile
 525             sh '''#!/usr/bin/env bash
 526               set -e
 527               rm -rf "${OUTPUT_DIR}" && mkdir "${OUTPUT_DIR}"
 528               echo '(x) {color:red}-1 jdk11 hadoop3 checks{color}' >"${OUTPUT_DIR}/commentfile"
 529               echo "-- Something went wrong running this stage, please [check relevant console output|${BUILD_URL}/console]." >> "${OUTPUT_DIR}/commentfile"
 530 '''
 531             unstash 'yetus'
 532             dir('component') {
 533               checkout scm
 534             }
 535             sh '''#!/usr/bin/env bash
 536               set -e
 537               rm -rf "${OUTPUT_DIR}/machine" && mkdir "${OUTPUT_DIR}/machine"
 538               "${BASEDIR}/dev-support/gather_machine_environment.sh" "${OUTPUT_DIR_RELATIVE}/machine"
 539               echo "got the following saved stats in '${OUTPUT_DIR_RELATIVE}/machine'"
 540               ls -lh "${OUTPUT_DIR_RELATIVE}/machine"
 541 '''
 542             sh '''#!/usr/bin/env bash
 543               set -e
 544               declare -i status=0
 545               if "${BASEDIR}/dev-support/hbase_nightly_yetus.sh" ; then
 546                 echo '(/) {color:green}+1 jdk11 hadoop3 checks{color}' > "${OUTPUT_DIR}/commentfile"
 547               else
 548                 echo '(x) {color:red}-1 jdk11 hadoop3 checks{color}' > "${OUTPUT_DIR}/commentfile"
 549                 status=1
 550               fi
 551               echo "-- For more information [see jdk11 report|${BUILD_URL}/JDK11_Nightly_Build_Report/]" >> "${OUTPUT_DIR}/commentfile"
 552               exit "${status}"
 553             '''
 554           }
 555           post {
 556             always {
 557               stash name: 'jdk11-hadoop3-result', includes: "${OUTPUT_DIR_RELATIVE}/commentfile"
 558               junit testResults: "${env.OUTPUT_DIR_RELATIVE}/**/target/**/TEST-*.xml", allowEmptyResults: true
 559               // zip surefire reports.
 560               sh '''#!/bin/bash -e
 561                 if [ -d "${OUTPUT_DIR}/archiver" ]; then
 562                   count=$(find "${OUTPUT_DIR}/archiver" -type f | wc -l)
 563                   if [[ 0 -ne ${count} ]]; then
 564                     echo "zipping ${count} archived files"
 565                     zip -q -m -r "${OUTPUT_DIR}/test_logs.zip" "${OUTPUT_DIR}/archiver"
 566                   else
 567                     echo "No archived files, skipping compressing."
 568                   fi
 569                 else
 570                   echo "No archiver directory, skipping compressing."
 571                 fi
 572 '''
 573               // Has to be relative to WORKSPACE.
 574               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/*"
 575               archiveArtifacts artifacts: "${env.OUTPUT_DIR_RELATIVE}/**/*"
 576               publishHTML target: [
 577                 allowMissing         : true,
 578                 keepAll              : true,
 579                 alwaysLinkToLastBuild: true,
 580                 // Has to be relative to WORKSPACE.
 581                 reportDir            : "${env.OUTPUT_DIR_RELATIVE}",
 582                 reportFiles          : 'console-report.html',
 583                 reportName           : 'JDK11 Nightly Build Report'
 584               ]
 585             }
 586           }
 587         }
 588         // This is meant to mimic what a release manager will do to create RCs.
 589         // See http://hbase.apache.org/book.html#maven.release
 590         // TODO (HBASE-23870): replace this with invocation of the release tool
 591         stage ('packaging and integration') {
 592           tools {
 593             maven 'Maven (latest)'
 594             // this needs to be set to the jdk that ought to be used to build releases on the branch the Jenkinsfile is stored in.
 595             jdk "JDK 1.8 (latest)"
 596           }
 597           environment {
 598             BASEDIR = "${env.WORKSPACE}/component"
 599           }
 600           steps {
 601             sh '''#!/bin/bash -e
 602               echo "Setting up directories"
 603               rm -rf "output-srctarball" && mkdir "output-srctarball"
 604               rm -rf "output-integration" && mkdir "output-integration" "output-integration/hadoop-2" "output-integration/hadoop-3" "output-integration/hadoop-3-shaded"
 605               rm -rf "unpacked_src_tarball" && mkdir "unpacked_src_tarball"
 606               rm -rf "hbase-install" && mkdir "hbase-install"
 607               rm -rf "hbase-client" && mkdir "hbase-client"
 608               rm -rf "hadoop-2" && mkdir "hadoop-2"
 609               rm -rf "hadoop-3" && mkdir "hadoop-3"
 610               rm -rf ".m2-for-repo" && mkdir ".m2-for-repo"
 611               rm -rf ".m2-for-src" && mkdir ".m2-for-src"
 612               echo "(x) {color:red}-1 source release artifact{color}\n-- Something went wrong with this stage, [check relevant console output|${BUILD_URL}/console]." >output-srctarball/commentfile
 613               echo "(x) {color:red}-1 client integration test{color}\n-- Something went wrong with this stage, [check relevant console output|${BUILD_URL}/console]." >output-integration/commentfile
 614 '''
 615             sh '''#!/usr/bin/env bash
 616               set -e
 617               rm -rf "output-srctarball/machine" && mkdir "output-srctarball/machine"
 618               "${BASEDIR}/dev-support/gather_machine_environment.sh" "output-srctarball/machine"
 619               echo "got the following saved stats in 'output-srctarball/machine'"
 620               ls -lh "output-srctarball/machine"
 621 '''
 622             sh """#!/bin/bash -e
 623               echo "Checking the steps for an RM to make a source artifact, then a binary artifact."
 624               if "${env.BASEDIR}/dev-support/hbase_nightly_source-artifact.sh" \
 625                   --intermediate-file-dir output-srctarball \
 626                   --unpack-temp-dir unpacked_src_tarball \
 627                   --maven-m2-initial .m2-for-repo \
 628                   --maven-m2-src-build .m2-for-src \
 629                   --clean-source-checkout \
 630                   "${env.BASEDIR}" ; then
 631                 echo '(/) {color:green}+1 source release artifact{color}\n-- See build output for details.' >output-srctarball/commentfile
 632               else
 633                 echo '(x) {color:red}-1 source release artifact{color}\n-- See build output for details.' >output-srctarball/commentfile
 634                 exit 1
 635               fi
 636 """
 637             echo "unpacking the hbase bin tarball into 'hbase-install' and the client tarball into 'hbase-client'"
 638             sh '''#!/bin/bash -e
 639               if [ 2 -ne $(ls -1 "${WORKSPACE}"/unpacked_src_tarball/hbase-assembly/target/hbase-*-bin.tar.gz | wc -l) ]; then
 640                 echo '(x) {color:red}-1 testing binary artifact{color}\n-- source tarball did not produce the expected binaries.' >>output-srctarball/commentfile
 641                 exit 1
 642               fi
 643               install_artifact=$(ls -1 "${WORKSPACE}"/unpacked_src_tarball/hbase-assembly/target/hbase-*-bin.tar.gz | sort | head -n 1)
 644               tar --strip-component=1 -xzf "${install_artifact}" -C "hbase-install"
 645               client_artifact=$(ls -1 "${WORKSPACE}"/unpacked_src_tarball/hbase-assembly/target/hbase-*-bin.tar.gz | sort | tail -n 1)
 646               tar --strip-component=1 -xzf "${client_artifact}" -C "hbase-client"
 647 '''
 648             unstash 'hadoop-2'
 649             echo "Attempting to use run an instance on top of Hadoop 2."
 650             sh '''#!/bin/bash -xe
 651               artifact=$(ls -1 "${WORKSPACE}"/hadoop-2*.tar.gz | head -n 1)
 652               tar --strip-components=1 -xzf "${artifact}" -C "hadoop-2"
 653               if ! "${BASEDIR}/dev-support/hbase_nightly_pseudo-distributed-test.sh" \
 654                   --single-process \
 655                   --working-dir output-integration/hadoop-2 \
 656                   --hbase-client-install "hbase-client" \
 657                   "hbase-install" \
 658                   "hadoop-2/bin/hadoop" \
 659                   hadoop-2/share/hadoop/yarn/test/hadoop-yarn-server-tests-*-tests.jar \
 660                   hadoop-2/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-*-tests.jar \
 661                   hadoop-2/bin/mapred \
 662                   >output-integration/hadoop-2.log 2>&1 ; then
 663                 echo "(x) {color:red}-1 client integration test{color}\n--Failed when running client tests on top of Hadoop 2. [see log for details|${BUILD_URL}/artifact/output-integration/hadoop-2.log]. (note that this means we didn't run on Hadoop 3)" >output-integration/commentfile
 664                 exit 2
 665               fi
 666 '''
 667             unstash 'hadoop-3'
 668             echo "Attempting to use run an instance on top of Hadoop 3."
 669             sh '''#!/bin/bash -e
 670               artifact=$(ls -1 "${WORKSPACE}"/hadoop-3*.tar.gz | head -n 1)
 671               tar --strip-components=1 -xzf "${artifact}" -C "hadoop-3"
 672               if ! "${BASEDIR}/dev-support/hbase_nightly_pseudo-distributed-test.sh" \
 673                   --single-process \
 674                   --working-dir output-integration/hadoop-3 \
 675                   --hbase-client-install hbase-client \
 676                   hbase-install \
 677                   hadoop-3/bin/hadoop \
 678                   hadoop-3/share/hadoop/yarn/test/hadoop-yarn-server-tests-*-tests.jar \
 679                   hadoop-3/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-*-tests.jar \
 680                   hadoop-3/bin/mapred \
 681                   >output-integration/hadoop-3.log 2>&1 ; then
 682                 echo "(x) {color:red}-1 client integration test{color}\n--Failed when running client tests on top of Hadoop 3. [see log for details|${BUILD_URL}/artifact/output-integration/hadoop-3.log]. (note that this means we didn't check the Hadoop 3 shaded client)" >output-integration/commentfile
 683                 exit 2
 684               fi
 685               echo "Attempting to use run an instance on top of Hadoop 3, relying on the Hadoop client artifacts for the example client program."
 686               if ! "${BASEDIR}/dev-support/hbase_nightly_pseudo-distributed-test.sh" \
 687                   --single-process \
 688                   --hadoop-client-classpath hadoop-3/share/hadoop/client/hadoop-client-api-*.jar:hadoop-3/share/hadoop/client/hadoop-client-runtime-*.jar \
 689                   --working-dir output-integration/hadoop-3-shaded \
 690                   --hbase-client-install hbase-client \
 691                   hbase-install \
 692                   hadoop-3/bin/hadoop \
 693                   hadoop-3/share/hadoop/yarn/test/hadoop-yarn-server-tests-*-tests.jar \
 694                   hadoop-3/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-*-tests.jar \
 695                   hadoop-3/bin/mapred \
 696                   >output-integration/hadoop-3-shaded.log 2>&1 ; then
 697                 echo "(x) {color:red}-1 client integration test{color}\n--Failed when running client tests on top of Hadoop 3 using Hadoop's shaded client. [see log for details|${BUILD_URL}/artifact/output-integration/hadoop-3-shaded.log]." >output-integration/commentfile
 698                 exit 2
 699               fi
 700               echo "(/) {color:green}+1 client integration test{color}" >output-integration/commentfile
 701 '''
 702
 703
 704           }
 705           post {
 706             always {
 707               stash name: 'srctarball-result', includes: "output-srctarball/commentfile,output-integration/commentfile"
 708               archiveArtifacts artifacts: 'output-srctarball/*'
 709               archiveArtifacts artifacts: 'output-srctarball/**/*'
 710               archiveArtifacts artifacts: 'output-integration/*'
 711               archiveArtifacts artifacts: 'output-integration/**/*'
 712             }
 713           }
 714         }
 715       }
 716     }
 717   }
 718   post {
 719     always {
 720       script {
 721          try {
 722            unstash 'general-result'
 723            unstash 'jdk7-result'
 724            unstash 'jdk8-hadoop2-result'
 725            unstash 'jdk8-hadoop3-result'
 726            unstash 'jdk11-hadoop3-result'
 727            unstash 'srctarball-result'
 728            sh "printenv"
 729            def results = ["${env.OUTPUT_DIR_RELATIVE_GENERAL}/commentfile",
 730                           "${env.OUTPUT_DIR_RELATIVE_JDK7}/commentfile",
 731                           "${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP2}/commentfile",
 732                           "${env.OUTPUT_DIR_RELATIVE_JDK8_HADOOP3}/commentfile",
 733                           "${env.OUTPUT_DIR_RELATIVE_JDK11_HADOOP3}/commentfile",
 734                           'output-srctarball/commentfile',
 735                           'output-integration/commentfile']
 736            echo env.BRANCH_NAME
 737            echo env.BUILD_URL
 738            echo currentBuild.result
 739            echo currentBuild.durationString
 740            def comment = "Results for branch ${env.BRANCH_NAME}\n"
 741            comment += "\t[build ${currentBuild.displayName} on builds.a.o|${env.BUILD_URL}]: "
 742            if (currentBuild.result == null || currentBuild.result == "SUCCESS") {
 743               comment += "(/) *{color:green}+1 overall{color}*\n"
 744            } else {
 745               comment += "(x) *{color:red}-1 overall{color}*\n"
 746               // Ideally get the committer our of the change and @ mention them in the per-jira comment
 747            }
 748            comment += "----\ndetails (if available):\n\n"
 749            echo ""
 750            echo "[DEBUG] trying to aggregate step-wise results"
 751            comment += results.collect { fileExists(file: it) ? readFile(file: it) : "" }.join("\n\n")
 752            echo "[INFO] Comment:"
 753            echo comment
 754            echo ""
 755            echo "[DEBUG] checking to see if feature branch"
 756            def jiras = getJirasToComment(env.BRANCH_NAME, [])
 757            if (jiras.isEmpty()) {
 758              echo "[DEBUG] non-feature branch, checking change messages for jira keys."
 759              echo "[INFO] There are ${currentBuild.changeSets.size()} change sets."
 760              jiras = getJirasToCommentFromChangesets(currentBuild)
 761            }
 762            jiras.each { currentIssue ->
 763              jiraComment issueKey: currentIssue, body: comment
 764            }
 765         } catch (Exception exception) {
 766           echo "Got exception: ${exception}"
 767           echo "    ${exception.getStackTrace()}"
 768         }
 769       }
 770     }
 771   }
 772 }
 773 import org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper
 774 @NonCPS
 775 List<String> getJirasToCommentFromChangesets(RunWrapper thisBuild) {
 776   def seenJiras = []
 777   thisBuild.changeSets.each { cs ->
 778     cs.getItems().each { change ->
 779       CharSequence msg = change.msg
 780       echo "change: ${change}"
 781       echo "     ${msg}"
 782       echo "     ${change.commitId}"
 783       echo "     ${change.author}"
 784       echo ""
 785       seenJiras = getJirasToComment(msg, seenJiras)
 786     }
 787   }
 788   return seenJiras
 789 }
 790 @NonCPS
 791 List<String> getJirasToComment(CharSequence source, List<String> seen) {
 792   source.eachMatch("HBASE-[0-9]+") { currentIssue ->
 793     echo "[DEBUG] found jira key: ${currentIssue}"
 794     if (currentIssue in seen) {
 795       echo "[DEBUG] already commented on ${currentIssue}."
 796     } else {
 797       echo "[INFO] commenting on ${currentIssue}."
 798       seen << currentIssue
 799     }
 800   }
 801   return seen
 802 }