merge.pr.yml

name: Build docker images

on:
  push:
    branches:
      - main

env:
  NODE: "16.15.1"
  RAPIDS: "22.02.00"
  REPOSITORY: "ghcr.io/rapidsai/node"

concurrency:
  group: build_docker_images
  cancel-in-progress: true

jobs:

  build-and-publish-devel-main-image:
    name: Build devel main image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            dev/dockerfiles/devel/main\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        uses: ./.github/actions/build-and-publish-image
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/devel/main.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main
          build-args: |
            "NODE_VERSION=${{ env.NODE }}"
            "SCCACHE_IDLE_TIMEOUT=32768"
            "SCCACHE_REGION=us-west-2"
            "SCCACHE_BUCKET=node-rapids-sccache"
            "ARM64_BASE=nvcr.io/nvidia/l4t-cuda:11.4.14-runtime"
            "AMD64_BASE=nvidia/cuda:${{ matrix.CUDA }}-devel-${{ matrix.LINUX }}"

  build-and-publish-devel-packages-image:
    needs:
      - build-and-publish-devel-main-image
    name: Build devel packages image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules
            yarn\.lock
            package\.json
            dev/dockerfiles/devel/(main|package)\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        uses: ./.github/actions/build-and-publish-image
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/devel/package.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages
          build-args: |
            "CUDAARCHS=ALL"
            "PARALLEL_LEVEL=1"
            "SCCACHE_IDLE_TIMEOUT=32768"
            "SCCACHE_REGION=us-west-2"
            "SCCACHE_BUCKET=node-rapids-sccache"
            "RAPIDS_VERSION=${{ env.RAPIDS }}"
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-cuda-base-image:
    needs:
      - build-and-publish-devel-main-image
      - build-and-publish-devel-packages-image
    name: Build runtime cuda-base image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            dev/dockerfiles/runtime/base\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/base.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base
          build-args: |
            "UID=1000"
            "ARM64_BASE=nvcr.io/nvidia/l4t-cuda:11.4.14-runtime"
            "AMD64_BASE=nvidia/cuda:${{ matrix.CUDA }}-runtime-${{ matrix.LINUX }}"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-cudf-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime cudf image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(rmm|core|cuda|cudf)
            dev/dockerfiles/runtime/cudf\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/cudf.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-cudf
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-cugraph-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime cugraph image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(rmm|core|cuda|cudf|cugraph)
            dev/dockerfiles/runtime/cugraph\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/cugraph.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-cugraph
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-cuml-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime cuml image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(rmm|core|cuda|cudf|cuml)
            dev/dockerfiles/runtime/cuml\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/cuml.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-cuml
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-cuspatial-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime cuspatial image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(rmm|core|cuda|cudf|cuspatial)
            dev/dockerfiles/runtime/cuspatial\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/cuspatial.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-cuspatial
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-glfw-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime glfw image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(core|glfw|webgl)
            dev/dockerfiles/runtime/glfw\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/glfw.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-glfw
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-sql-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime sql image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(rmm|core|cuda|cudf|sql)
            dev/dockerfiles/runtime/sql\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/sql.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-sql
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-main-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime main image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules/(core|cuda|glfw|webgl|rmm|cudf|sql|cuml|cugraph|cuspatial|deck\.gl|jsdom)
            dev/dockerfiles/runtime/main\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/main.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-demo-image:
    needs:
      - build-and-publish-devel-packages-image
      - build-and-publish-runtime-cuda-base-image
    name: Build runtime demo image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules
            dev/dockerfiles/runtime/demo\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/demo.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-demo
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-base"
            "BUILD_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-packages"
            "DEVEL_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-devel-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-main"

  build-and-publish-runtime-notebook-image:
    needs:
      - build-and-publish-runtime-demo-image
    name: Build runtime notebook image
    runs-on: ubuntu-20.04
    strategy:
      fail-fast: true
      matrix:
        CUDA: ["11.6.2"]
        LINUX: ["ubuntu20.04"]
    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          lfs: true
          fetch-depth: 2
      - name: Checkout LFS
        run: git lfs checkout
      - name: Check if files changed
        id: files_changed
        uses: tj-actions/changed-files@v9.1
        with:
          files: |
            \.npmrc
            modules
            **/*\.ipynb
            dev/dockerfiles/runtime/notebook\.Dockerfile
            \.github/workflows/merge\.pr\.yml
            \.github/actions/build-and-publish-image/action\.yml
      - name: Build and push image
        uses: ./.github/actions/build-and-publish-image
        if: ${{ steps.files_changed.outputs.any_changed == 'true' || steps.files_changed.outputs.any_deleted == 'true' }}
        with:
          registry-url: ghcr.io
          registry-username: ${{ github.repository_owner }}
          registry-password: ${{ github.token }}
          pull: true
          push: ${{ github.event_name == 'push' }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          file: dev/dockerfiles/runtime/notebook.Dockerfile
          tags: |
            ${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-notebook
          build-args: |
            "FROM_IMAGE=${{ env.REPOSITORY }}:${{ env.RAPIDS }}-runtime-node${{ env.NODE }}-cuda${{ matrix.CUDA }}-${{ matrix.LINUX }}-demo"