github.com/Heebron/moby@v0.0.0-20221111184709-6eab4f55faf7/Jenkinsfile (about)

     1  #!groovy
     2  pipeline {
     3      agent none
     4  
     5      options {
     6          buildDiscarder(logRotator(daysToKeepStr: '30'))
     7          timeout(time: 2, unit: 'HOURS')
     8          timestamps()
     9      }
    10      parameters {
    11          booleanParam(name: 'arm64', defaultValue: true, description: 'ARM (arm64) Build/Test')
    12          booleanParam(name: 's390x', defaultValue: false, description: 'IBM Z (s390x) Build/Test')
    13          booleanParam(name: 'ppc64le', defaultValue: false, description: 'PowerPC (ppc64le) Build/Test')
    14          booleanParam(name: 'dco', defaultValue: true, description: 'Run the DCO check')
    15      }
    16      environment {
    17          DOCKER_BUILDKIT     = '1'
    18          DOCKER_EXPERIMENTAL = '1'
    19          DOCKER_GRAPHDRIVER  = 'overlay2'
    20          APT_MIRROR          = 'cdn-fastly.deb.debian.org'
    21          CHECK_CONFIG_COMMIT = '33a3680e08d1007e72c3b3f1454f823d8e9948ee'
    22          TESTDEBUG           = '0'
    23          TIMEOUT             = '120m'
    24      }
    25      stages {
    26          stage('pr-hack') {
    27              when { changeRequest() }
    28              steps {
    29                  script {
    30                      echo "Workaround for PR auto-cancel feature. Borrowed from https://issues.jenkins-ci.org/browse/JENKINS-43353"
    31                      def buildNumber = env.BUILD_NUMBER as int
    32                      if (buildNumber > 1) milestone(buildNumber - 1)
    33                      milestone(buildNumber)
    34                  }
    35              }
    36          }
    37          stage('DCO-check') {
    38              when {
    39                  beforeAgent true
    40                  expression { params.dco }
    41              }
    42              agent { label 'arm64 && ubuntu-2004' }
    43              steps {
    44                  sh '''
    45                  docker run --rm \
    46                    -v "$WORKSPACE:/workspace" \
    47                    -e VALIDATE_REPO=${GIT_URL} \
    48                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
    49                    alpine sh -c 'apk add --no-cache -q bash git openssh-client && git config --system --add safe.directory /workspace && cd /workspace && hack/validate/dco'
    50                  '''
    51              }
    52          }
    53          stage('Build') {
    54              parallel {
    55                  stage('s390x') {
    56                      when {
    57                          beforeAgent true
    58                          // Skip this stage on PRs unless the checkbox is selected
    59                          anyOf {
    60                              not { changeRequest() }
    61                              expression { params.s390x }
    62                          }
    63                      }
    64                      agent { label 's390x-ubuntu-2004' }
    65  
    66                      stages {
    67                          stage("Print info") {
    68                              steps {
    69                                  sh 'docker version'
    70                                  sh 'docker info'
    71                                  sh '''
    72                                  echo "check-config.sh version: ${CHECK_CONFIG_COMMIT}"
    73                                  curl -fsSL -o ${WORKSPACE}/check-config.sh "https://raw.githubusercontent.com/moby/moby/${CHECK_CONFIG_COMMIT}/contrib/check-config.sh" \
    74                                  && bash ${WORKSPACE}/check-config.sh || true
    75                                  '''
    76                              }
    77                          }
    78                          stage("Build dev image") {
    79                              steps {
    80                                  sh '''
    81                                  docker build --force-rm --build-arg APT_MIRROR -t docker:${GIT_COMMIT} .
    82                                  '''
    83                              }
    84                          }
    85                          stage("Unit tests") {
    86                              steps {
    87                                  sh '''
    88                                  sudo modprobe ip6table_filter
    89                                  '''
    90                                  sh '''
    91                                  docker run --rm -t --privileged \
    92                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
    93                                    --name docker-pr$BUILD_NUMBER \
    94                                    -e DOCKER_EXPERIMENTAL \
    95                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
    96                                    -e DOCKER_GRAPHDRIVER \
    97                                    -e VALIDATE_REPO=${GIT_URL} \
    98                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
    99                                    docker:${GIT_COMMIT} \
   100                                    hack/test/unit
   101                                  '''
   102                              }
   103                              post {
   104                                  always {
   105                                      junit testResults: 'bundles/junit-report*.xml', allowEmptyResults: true
   106                                  }
   107                              }
   108                          }
   109                          stage("Integration tests") {
   110                              environment { TEST_SKIP_INTEGRATION_CLI = '1' }
   111                              steps {
   112                                  sh '''
   113                                  docker run --rm -t --privileged \
   114                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   115                                    --name docker-pr$BUILD_NUMBER \
   116                                    -e DOCKER_EXPERIMENTAL \
   117                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   118                                    -e DOCKER_GRAPHDRIVER \
   119                                    -e TESTDEBUG \
   120                                    -e TEST_INTEGRATION_USE_SNAPSHOTTER \
   121                                    -e TEST_SKIP_INTEGRATION_CLI \
   122                                    -e TIMEOUT \
   123                                    -e VALIDATE_REPO=${GIT_URL} \
   124                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   125                                    docker:${GIT_COMMIT} \
   126                                    hack/make.sh \
   127                                      dynbinary \
   128                                      test-integration
   129                                  '''
   130                              }
   131                              post {
   132                                  always {
   133                                      junit testResults: 'bundles/**/*-report.xml', allowEmptyResults: true
   134                                  }
   135                              }
   136                          }
   137                      }
   138  
   139                      post {
   140                          always {
   141                              sh '''
   142                              echo "Ensuring container killed."
   143                              docker rm -vf docker-pr$BUILD_NUMBER || true
   144                              '''
   145  
   146                              sh '''
   147                              echo "Chowning /workspace to jenkins user"
   148                              docker run --rm -v "$WORKSPACE:/workspace" busybox chown -R "$(id -u):$(id -g)" /workspace
   149                              '''
   150  
   151                              catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE', message: 'Failed to create bundles.tar.gz') {
   152                                  sh '''
   153                                  bundleName=s390x-integration
   154                                  echo "Creating ${bundleName}-bundles.tar.gz"
   155                                  # exclude overlay2 directories
   156                                  find bundles -path '*/root/*overlay2' -prune -o -type f \\( -name '*-report.json' -o -name '*.log' -o -name '*.prof' -o -name '*-report.xml' \\) -print | xargs tar -czf ${bundleName}-bundles.tar.gz
   157                                  '''
   158  
   159                                  archiveArtifacts artifacts: '*-bundles.tar.gz', allowEmptyArchive: true
   160                              }
   161                          }
   162                          cleanup {
   163                              sh 'make clean'
   164                              deleteDir()
   165                          }
   166                      }
   167                  }
   168                  stage('s390x integration-cli') {
   169                      when {
   170                          beforeAgent true
   171                          // Skip this stage on PRs unless the checkbox is selected
   172                          anyOf {
   173                              not { changeRequest() }
   174                              expression { params.s390x }
   175                          }
   176                      }
   177                      agent { label 's390x-ubuntu-2004' }
   178  
   179                      stages {
   180                          stage("Print info") {
   181                              steps {
   182                                  sh 'docker version'
   183                                  sh 'docker info'
   184                                  sh '''
   185                                  echo "check-config.sh version: ${CHECK_CONFIG_COMMIT}"
   186                                  curl -fsSL -o ${WORKSPACE}/check-config.sh "https://raw.githubusercontent.com/moby/moby/${CHECK_CONFIG_COMMIT}/contrib/check-config.sh" \
   187                                  && bash ${WORKSPACE}/check-config.sh || true
   188                                  '''
   189                              }
   190                          }
   191                          stage("Build dev image") {
   192                              steps {
   193                                  sh '''
   194                                  docker build --force-rm --build-arg APT_MIRROR -t docker:${GIT_COMMIT} .
   195                                  '''
   196                              }
   197                          }
   198                          stage("Integration-cli tests") {
   199                              environment { TEST_SKIP_INTEGRATION = '1' }
   200                              steps {
   201                                  sh '''
   202                                  docker run --rm -t --privileged \
   203                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   204                                    --name docker-pr$BUILD_NUMBER \
   205                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   206                                    -e DOCKER_GRAPHDRIVER \
   207                                    -e TEST_INTEGRATION_USE_SNAPSHOTTER \
   208                                    -e TEST_SKIP_INTEGRATION \
   209                                    -e TIMEOUT \
   210                                    -e VALIDATE_REPO=${GIT_URL} \
   211                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   212                                    docker:${GIT_COMMIT} \
   213                                    hack/make.sh \
   214                                      dynbinary \
   215                                      test-integration
   216                                  '''
   217                              }
   218                              post {
   219                                  always {
   220                                      junit testResults: 'bundles/**/*-report.xml', allowEmptyResults: true
   221                                  }
   222                              }
   223                          }
   224                      }
   225  
   226                      post {
   227                          always {
   228                              sh '''
   229                              echo "Ensuring container killed."
   230                              docker rm -vf docker-pr$BUILD_NUMBER || true
   231                              '''
   232  
   233                              sh '''
   234                              echo "Chowning /workspace to jenkins user"
   235                              docker run --rm -v "$WORKSPACE:/workspace" busybox chown -R "$(id -u):$(id -g)" /workspace
   236                              '''
   237  
   238                              catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE', message: 'Failed to create bundles.tar.gz') {
   239                                  sh '''
   240                                  bundleName=s390x-integration-cli
   241                                  echo "Creating ${bundleName}-bundles.tar.gz"
   242                                  # exclude overlay2 directories
   243                                  find bundles -path '*/root/*overlay2' -prune -o -type f \\( -name '*-report.json' -o -name '*.log' -o -name '*.prof' -o -name '*-report.xml' \\) -print | xargs tar -czf ${bundleName}-bundles.tar.gz
   244                                  '''
   245  
   246                                  archiveArtifacts artifacts: '*-bundles.tar.gz', allowEmptyArchive: true
   247                              }
   248                          }
   249                          cleanup {
   250                              sh 'make clean'
   251                              deleteDir()
   252                          }
   253                      }
   254                  }
   255                  stage('ppc64le') {
   256                      when {
   257                          beforeAgent true
   258                          // Skip this stage on PRs unless the checkbox is selected
   259                          anyOf {
   260                              not { changeRequest() }
   261                              expression { params.ppc64le }
   262                          }
   263                      }
   264                      agent { label 'ppc64le-ubuntu-1604' }
   265                      // ppc64le machines run on Docker 18.06, and buildkit has some
   266                      // bugs on that version. Build and use buildx instead.
   267                      environment {
   268                          USE_BUILDX      = '1'
   269                          DOCKER_BUILDKIT = '0'
   270                      }
   271  
   272                      stages {
   273                          stage("Print info") {
   274                              steps {
   275                                  sh 'docker version'
   276                                  sh 'docker info'
   277                                  sh '''
   278                                  echo "check-config.sh version: ${CHECK_CONFIG_COMMIT}"
   279                                  curl -fsSL -o ${WORKSPACE}/check-config.sh "https://raw.githubusercontent.com/moby/moby/${CHECK_CONFIG_COMMIT}/contrib/check-config.sh" \
   280                                  && bash ${WORKSPACE}/check-config.sh || true
   281                                  '''
   282                              }
   283                          }
   284                          stage("Build dev image") {
   285                              steps {
   286                                  sh '''
   287                                  make bundles/buildx
   288                                  bundles/buildx build --load --force-rm --build-arg APT_MIRROR -t docker:${GIT_COMMIT} .
   289                                  '''
   290                              }
   291                          }
   292                          stage("Unit tests") {
   293                              steps {
   294                                  sh '''
   295                                  sudo modprobe ip6table_filter
   296                                  '''
   297                                  sh '''
   298                                  docker run --rm -t --privileged \
   299                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   300                                    --name docker-pr$BUILD_NUMBER \
   301                                    -e DOCKER_EXPERIMENTAL \
   302                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   303                                    -e DOCKER_GRAPHDRIVER \
   304                                    -e VALIDATE_REPO=${GIT_URL} \
   305                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   306                                    docker:${GIT_COMMIT} \
   307                                    hack/test/unit
   308                                  '''
   309                              }
   310                              post {
   311                                  always {
   312                                      junit testResults: 'bundles/junit-report*.xml', allowEmptyResults: true
   313                                  }
   314                              }
   315                          }
   316                          stage("Integration tests") {
   317                              environment { TEST_SKIP_INTEGRATION_CLI = '1' }
   318                              steps {
   319                                  sh '''
   320                                  docker run --rm -t --privileged \
   321                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   322                                    --name docker-pr$BUILD_NUMBER \
   323                                    -e DOCKER_EXPERIMENTAL \
   324                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   325                                    -e DOCKER_GRAPHDRIVER \
   326                                    -e TESTDEBUG \
   327                                    -e TEST_INTEGRATION_USE_SNAPSHOTTER \
   328                                    -e TEST_SKIP_INTEGRATION_CLI \
   329                                    -e TIMEOUT \
   330                                    -e VALIDATE_REPO=${GIT_URL} \
   331                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   332                                    docker:${GIT_COMMIT} \
   333                                    hack/make.sh \
   334                                      dynbinary \
   335                                      test-integration
   336                                  '''
   337                              }
   338                              post {
   339                                  always {
   340                                      junit testResults: 'bundles/**/*-report.xml', allowEmptyResults: true
   341                                  }
   342                              }
   343                          }
   344                      }
   345  
   346                      post {
   347                          always {
   348                              sh '''
   349                              echo "Ensuring container killed."
   350                              docker rm -vf docker-pr$BUILD_NUMBER || true
   351                              '''
   352  
   353                              sh '''
   354                              echo "Chowning /workspace to jenkins user"
   355                              docker run --rm -v "$WORKSPACE:/workspace" busybox chown -R "$(id -u):$(id -g)" /workspace
   356                              '''
   357  
   358                              catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE', message: 'Failed to create bundles.tar.gz') {
   359                                  sh '''
   360                                  bundleName=ppc64le-integration
   361                                  echo "Creating ${bundleName}-bundles.tar.gz"
   362                                  # exclude overlay2 directories
   363                                  find bundles -path '*/root/*overlay2' -prune -o -type f \\( -name '*-report.json' -o -name '*.log' -o -name '*.prof' -o -name '*-report.xml' \\) -print | xargs tar -czf ${bundleName}-bundles.tar.gz
   364                                  '''
   365  
   366                                  archiveArtifacts artifacts: '*-bundles.tar.gz', allowEmptyArchive: true
   367                              }
   368                          }
   369                          cleanup {
   370                              sh 'make clean'
   371                              deleteDir()
   372                          }
   373                      }
   374                  }
   375                  stage('ppc64le integration-cli') {
   376                      when {
   377                          beforeAgent true
   378                          // Skip this stage on PRs unless the checkbox is selected
   379                          anyOf {
   380                              not { changeRequest() }
   381                              expression { params.ppc64le }
   382                          }
   383                      }
   384                      agent { label 'ppc64le-ubuntu-1604' }
   385                      // ppc64le machines run on Docker 18.06, and buildkit has some
   386                      // bugs on that version. Build and use buildx instead.
   387                      environment {
   388                          USE_BUILDX      = '1'
   389                          DOCKER_BUILDKIT = '0'
   390                      }
   391  
   392                      stages {
   393                          stage("Print info") {
   394                              steps {
   395                                  sh 'docker version'
   396                                  sh 'docker info'
   397                                  sh '''
   398                                  echo "check-config.sh version: ${CHECK_CONFIG_COMMIT}"
   399                                  curl -fsSL -o ${WORKSPACE}/check-config.sh "https://raw.githubusercontent.com/moby/moby/${CHECK_CONFIG_COMMIT}/contrib/check-config.sh" \
   400                                  && bash ${WORKSPACE}/check-config.sh || true
   401                                  '''
   402                              }
   403                          }
   404                          stage("Build dev image") {
   405                              steps {
   406                                  sh '''
   407                                  make bundles/buildx
   408                                  bundles/buildx build --load --force-rm --build-arg APT_MIRROR -t docker:${GIT_COMMIT} .
   409                                  '''
   410                              }
   411                          }
   412                          stage("Integration-cli tests") {
   413                              environment { TEST_SKIP_INTEGRATION = '1' }
   414                              steps {
   415                                  sh '''
   416                                  docker run --rm -t --privileged \
   417                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   418                                    --name docker-pr$BUILD_NUMBER \
   419                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   420                                    -e DOCKER_GRAPHDRIVER \
   421                                    -e TEST_INTEGRATION_USE_SNAPSHOTTER \
   422                                    -e TEST_SKIP_INTEGRATION \
   423                                    -e TIMEOUT \
   424                                    -e VALIDATE_REPO=${GIT_URL} \
   425                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   426                                    docker:${GIT_COMMIT} \
   427                                    hack/make.sh \
   428                                      dynbinary \
   429                                      test-integration
   430                                  '''
   431                              }
   432                              post {
   433                                  always {
   434                                      junit testResults: 'bundles/**/*-report.xml', allowEmptyResults: true
   435                                  }
   436                              }
   437                          }
   438                      }
   439  
   440                      post {
   441                          always {
   442                              sh '''
   443                              echo "Ensuring container killed."
   444                              docker rm -vf docker-pr$BUILD_NUMBER || true
   445                              '''
   446  
   447                              sh '''
   448                              echo "Chowning /workspace to jenkins user"
   449                              docker run --rm -v "$WORKSPACE:/workspace" busybox chown -R "$(id -u):$(id -g)" /workspace
   450                              '''
   451  
   452                              catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE', message: 'Failed to create bundles.tar.gz') {
   453                                  sh '''
   454                                  bundleName=ppc64le-integration-cli
   455                                  echo "Creating ${bundleName}-bundles.tar.gz"
   456                                  # exclude overlay2 directories
   457                                  find bundles -path '*/root/*overlay2' -prune -o -type f \\( -name '*-report.json' -o -name '*.log' -o -name '*.prof' -o -name '*-report.xml' \\) -print | xargs tar -czf ${bundleName}-bundles.tar.gz
   458                                  '''
   459  
   460                                  archiveArtifacts artifacts: '*-bundles.tar.gz', allowEmptyArchive: true
   461                              }
   462                          }
   463                          cleanup {
   464                              sh 'make clean'
   465                              deleteDir()
   466                          }
   467                      }
   468                  }
   469                  stage('arm64') {
   470                      when {
   471                          beforeAgent true
   472                          expression { params.arm64 }
   473                      }
   474                      agent { label 'arm64 && ubuntu-2004' }
   475                      environment {
   476                          TEST_SKIP_INTEGRATION_CLI = '1'
   477                      }
   478  
   479                      stages {
   480                          stage("Print info") {
   481                              steps {
   482                                  sh 'docker version'
   483                                  sh 'docker info'
   484                                  sh '''
   485                                  echo "check-config.sh version: ${CHECK_CONFIG_COMMIT}"
   486                                  curl -fsSL -o ${WORKSPACE}/check-config.sh "https://raw.githubusercontent.com/moby/moby/${CHECK_CONFIG_COMMIT}/contrib/check-config.sh" \
   487                                  && bash ${WORKSPACE}/check-config.sh || true
   488                                  '''
   489                              }
   490                          }
   491                          stage("Build dev image") {
   492                              steps {
   493                                  sh 'docker build --force-rm --build-arg APT_MIRROR -t docker:${GIT_COMMIT} .'
   494                              }
   495                          }
   496                          stage("Unit tests") {
   497                              steps {
   498                                  sh '''
   499                                  sudo modprobe ip6table_filter
   500                                  '''
   501                                  sh '''
   502                                  docker run --rm -t --privileged \
   503                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   504                                    --name docker-pr$BUILD_NUMBER \
   505                                    -e DOCKER_EXPERIMENTAL \
   506                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   507                                    -e DOCKER_GRAPHDRIVER \
   508                                    -e VALIDATE_REPO=${GIT_URL} \
   509                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   510                                    docker:${GIT_COMMIT} \
   511                                    hack/test/unit
   512                                  '''
   513                              }
   514                              post {
   515                                  always {
   516                                      junit testResults: 'bundles/junit-report*.xml', allowEmptyResults: true
   517                                  }
   518                              }
   519                          }
   520                          stage("Integration tests") {
   521                              environment { TEST_SKIP_INTEGRATION_CLI = '1' }
   522                              steps {
   523                                  sh '''
   524                                  docker run --rm -t --privileged \
   525                                    -v "$WORKSPACE/bundles:/go/src/github.com/docker/docker/bundles" \
   526                                    --name docker-pr$BUILD_NUMBER \
   527                                    -e DOCKER_EXPERIMENTAL \
   528                                    -e DOCKER_GITCOMMIT=${GIT_COMMIT} \
   529                                    -e DOCKER_GRAPHDRIVER \
   530                                    -e TESTDEBUG \
   531                                    -e TEST_INTEGRATION_USE_SNAPSHOTTER \
   532                                    -e TEST_SKIP_INTEGRATION_CLI \
   533                                    -e TIMEOUT \
   534                                    -e VALIDATE_REPO=${GIT_URL} \
   535                                    -e VALIDATE_BRANCH=${CHANGE_TARGET} \
   536                                    docker:${GIT_COMMIT} \
   537                                    hack/make.sh \
   538                                      dynbinary \
   539                                      test-integration
   540                                  '''
   541                              }
   542                              post {
   543                                  always {
   544                                      junit testResults: 'bundles/**/*-report.xml', allowEmptyResults: true
   545                                  }
   546                              }
   547                          }
   548                      }
   549  
   550                      post {
   551                          always {
   552                              sh '''
   553                              echo "Ensuring container killed."
   554                              docker rm -vf docker-pr$BUILD_NUMBER || true
   555                              '''
   556  
   557                              sh '''
   558                              echo "Chowning /workspace to jenkins user"
   559                              docker run --rm -v "$WORKSPACE:/workspace" busybox chown -R "$(id -u):$(id -g)" /workspace
   560                              '''
   561  
   562                              catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE', message: 'Failed to create bundles.tar.gz') {
   563                                  sh '''
   564                                  bundleName=arm64-integration
   565                                  echo "Creating ${bundleName}-bundles.tar.gz"
   566                                  # exclude overlay2 directories
   567                                  find bundles -path '*/root/*overlay2' -prune -o -type f \\( -name '*-report.json' -o -name '*.log' -o -name '*.prof' -o -name '*-report.xml' \\) -print | xargs tar -czf ${bundleName}-bundles.tar.gz
   568                                  '''
   569  
   570                                  archiveArtifacts artifacts: '*-bundles.tar.gz', allowEmptyArchive: true
   571                              }
   572                          }
   573                          cleanup {
   574                              sh 'make clean'
   575                              deleteDir()
   576                          }
   577                      }
   578                  }
   579              }
   580          }
   581      }
   582  }