e2e.yml

name: e2e tests

on: 
  push:
    branches: [main, k8s-sync-*]
  pull_request:
  workflow_dispatch:
    inputs:
      operator_image:
        description: 'Name of an existing operator image. Leave blank to build one with the default name'
        type: string
        required: false
      full_vertica_image:
        description: 'Name of an existing full vertica v2 image. Leave blank to build one with the default name'
        type: string
        required: false
      minimal_vertica_image:
        description: 'Name of an existing minimal vertica v2 image. Leave blank to build one with the default name'
        type: string
        required: false
      legacy_vertica_image:
        description: 'Name of an existing full image with admintools and SSH support. Leave blank to build one with the default name'
        type: string
        required: false
      vlogger_image:
        description: 'Name of an existing vlogger image. Leave blank to build one with the default name'
        type: string
        required: false
      e2e_test_suites:
        description: 'E2E test suites to run'
        required: false
        type: choice
        default: all
        options:
        - all
        - none
        - admintools leg 1 
        - admintools leg 2
        - admintools leg 3
        - admintools leg 4
        - admintools leg 4 vdb-gen
        - admintools leg 5
        - admintools server upgrade
        - admintools operator upgrade
        - admintools udx
        - vcluster leg 1
        - vcluster leg 2
        - vcluster leg 3
        - vcluster leg 4
        - vcluster leg 4 vdb-gen
        - vcluster leg 5
        - vcluster leg 6
        - vcluster leg 6 revivedb
        - vcluster leg 7
        - leg 8
        - vcluster leg 9
        - vcluster leg 10
        - vcluster server upgrade
        - vcluster udx
      run_security_scan:
        description: 'What images to scan?'
        type: choice
        default: 'all, except vertica server'
        options:
        - all
        - none
        - all, except vertica server
      build_release_assets:
        description: 'Build the release assets?'
        type: choice
        options:
        - all
        - none
        default: all
        required: false
      reason:
        description: 'Descriptive name of the workflow run'
        required: false
        default: ''

run-name: ${{ inputs.reason }}

jobs:
  build:
    uses: ./.github/workflows/build-images.yml
    with:
      vlogger_image: ${{ inputs.vlogger_image }}
      operator_image: ${{ inputs.operator_image }}
      minimal_vertica_image: ${{ inputs.minimal_vertica_image }}
      full_vertica_image: ${{ inputs.full_vertica_image }}
      legacy_vertica_image: ${{ inputs.legacy_vertica_image }}
      run_security_scan: ${{ inputs.run_security_scan }}
    secrets:
      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
      DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}

  unittests:
    uses: ./.github/workflows/unittests.yml
    secrets:
      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
      DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}

  scorecardtests:
    uses: ./.github/workflows/scorecardtests.yml

  build-release-assets:
    uses: ./.github/workflows/build-release-assets.yml
    if: ${{ inputs.build_release_assets == 'all' || inputs.build_release_assests == '' }}

  e2e-leg-1-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 1' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-1'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: azb
          deploy-with: olm
          need-legacy-image: true
  
  e2e-leg-1-admintools-previous-release:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 1' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-1'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: "opentext/vertica-k8s:23.4.0-0-minimal"
          artifact-suffix: "-23.4.0-release"
          vertica-deployment-method: admintools
          communal-storage-type: azb
          deploy-with: olm

  e2e-leg-1-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 1' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-1'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: azb
          deploy-with: olm

  e2e-leg-2-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 2' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-2'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: hostpath
          controllers-scope: namespace
          need-legacy-image: true

  e2e-leg-2-admintools-previous-release:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 2' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-2'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: "opentext/vertica-k8s:12.0.4-0-minimal"
          artifact-suffix: "-12.0.4-release"
          vertica-deployment-method: admintools
          communal-storage-type: hostpath
          controllers-scope: namespace

  e2e-leg-2-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 2' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-2'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath
          controllers-scope: namespace

  e2e-leg-3-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 3' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-3'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: hostpath
          need-legacy-image: true
  
  e2e-leg-3-vclusterops-previous-release:
    if: ${{ inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 3' || inputs.e2e_test_suites == '' }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-3'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: "opentext/vertica-k8s:24.1.0-0-minimal"
          artifact-suffix: "-24.1.0-release"
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath

  e2e-leg-3-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 3' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-3'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath

  e2e-leg-4-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 4' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-4'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: s3
          vertica-superuser-name: dbadmin
          # All helm deployments will use cert-manager to create the webhook cert
          helm-overrides: '--set webhook.certSource=cert-manager'
          need-legacy-image: true
  
  e2e-leg-4-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 4' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-4'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          vertica-superuser-name: myadmin
          # All helm deployments will use cert-manager to create the webhook cert
          helm-overrides: '--set webhook.certSource=cert-manager'

  e2e-leg-4-admintools-vdb-gen:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 4 vdb-gen' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-4-vdb-gen'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: s3
          vertica-superuser-name: dbadmin
          # All helm deployments will use cert-manager to create the webhook cert
          helm-overrides: '--set webhook.certSource=cert-manager'
          need-legacy-image: true
  
  e2e-leg-4-vcluster-vdb-gen:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 4 vdb-gen' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-4-vdb-gen'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          vertica-superuser-name: myadmin
          # All helm deployments will use cert-manager to create the webhook cert
          helm-overrides: '--set webhook.certSource=cert-manager'

  e2e-leg-5-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools leg 5' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-5'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: hostpath
          # We cannot parallelize these tests because they each deploy/undeploy
          # the cluster scoped operator. You can only have a single verticadb
          # operator running in the k8s cluster.
          e2e-parallelism: 1
          need-base-vertica-image: 'true'
          need-legacy-image: true

  e2e-leg-5-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 5' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-5'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath
          # We cannot parallelize these tests because they each deploy/undeploy
          # the cluster scoped operator. You can only have a single verticadb
          # operator running in the k8s cluster.
          e2e-parallelism: 1
          need-base-vertica-image: 'true'

  e2e-leg-6-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 6' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-6'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath
          minimum-vertica-image: '24.2.0'

  e2e-leg-6-vcluster-revivedb:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 6 revivedb' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-6-revivedb'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath
          minimum-vertica-image: '24.2.0'

  e2e-leg-7-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 7' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-7'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: hostpath
          minimum-vertica-image: '24.2.0'

  e2e-leg-8-vcluster-offline:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'leg 8' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-8-offline'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          # The initial deployment method is admintools, and it eventually changes
          # to vclusterops as the operator upgrades the server version
          vertica-deployment-method: admintools
          communal-storage-type: azb
          minimum-vertica-image: '24.2.0'

  e2e-leg-8-vcluster-online:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'leg 8' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-8-online'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          # The initial deployment method is admintools, and it eventually changes
          # to vclusterops as the operator upgrades the server version
          vertica-deployment-method: admintools
          communal-storage-type: azb
          minimum-vertica-image: '24.2.0'

  e2e-leg-9-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 9' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-9'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          minimum-vertica-image: '24.3.0'
          # Include the vertica license so we can test scaling past 3 nodes.
          vertica-license: ${{ secrets.VERTICA_LICENSE }}
          need-base-vertica-image: 'true'

  e2e-leg-10-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 10' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-10'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.minimal-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          minimum-vertica-image: '24.3.0'
          # Include the vertica license so we can test scaling past 3 nodes.
          vertica-license: ${{ secrets.VERTICA_LICENSE }}
          need-base-vertica-image: 'true'

  e2e-leg-11-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster leg 11' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'leg-11'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          vproxy-image: 'opentext/client-proxy:latest'
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          minimum-vertica-image: '25.1.0'
          # Include the vertica license so we can test multiple subclusters.
          vertica-license: ${{ secrets.VERTICA_LICENSE }}
          need-base-vertica-image: 'true'

  e2e-server-upgrade-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools server upgrade' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'server-upgrade'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: s3
          need-base-vertica-image: 'true'
          need-legacy-image: true

  e2e-server-upgrade-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster server upgrade' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'server-upgrade'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
          need-base-vertica-image: 'true'

  e2e-operator-upgrade:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools operator upgrade' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'operator-upgrade'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          communal-storage-type: s3
          # We cannot parallelize these tests because they each deploy/undeploy
          # the cluster scoped operator. You can only have a single verticadb
          # operator running in the k8s cluster.
          e2e-parallelism: 1
          vertica-deployment-method: admintools
          need-legacy-image: true

  e2e-udx-admintools:
    if: ${{ ! contains(github.ref, 'k8s-sync')  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'admintools udx' || inputs.e2e_test_suites == '') }}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'udx'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          vertica-image: ${{ needs.build.outputs.legacy-vertica-image }}
          vertica-deployment-method: admintools
          communal-storage-type: s3
          need-legacy-image: true
          # For admintools udx test, we are not using the test image,
          # and we still need to download some test packages.
          skip-download-test-packages: false

  e2e-udx-vcluster:
    if: ${{ ! github.event.pull_request.head.repo.fork  && (inputs.e2e_test_suites == 'all' || inputs.e2e_test_suites == 'vcluster udx' || inputs.e2e_test_suites == '')}}
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Test
        uses: ./.github/actions/run-e2e-leg
        with:
          leg-identifier: 'udx'
          dockerhub-username: ${{ secrets.DOCKERHUB_USERNAME }}
          dockerhub-token: ${{ secrets.DOCKERHUB_TOKEN }}
          vlogger-image: ${{ needs.build.outputs.vlogger-image }}
          operator-image: ${{ needs.build.outputs.operator-image }}
          # We must pass the full image since the minimal image cannot run Java UDx's
          vertica-image: ${{ needs.build.outputs.full-vertica-image }}
          vertica-deployment-method: vclusterops
          communal-storage-type: s3
  
  upload-operator-to-private-repo:
    needs: [
      build,
      e2e-leg-1-vcluster,
      e2e-leg-2-vcluster,
      e2e-leg-3-vclusterops-previous-release,
      e2e-leg-3-vcluster,
      e2e-leg-4-vcluster,
      e2e-leg-4-vcluster-vdb-gen,
      e2e-leg-5-vcluster,
      e2e-leg-6-vcluster,
      e2e-leg-6-vcluster-revivedb,
      e2e-leg-7-vcluster,
      e2e-leg-8-vcluster-offline,
      e2e-leg-8-vcluster-online,
      e2e-leg-9-vcluster,
      e2e-leg-10-vcluster,
      e2e-server-upgrade-vcluster,
      e2e-operator-upgrade,
      e2e-udx-vcluster,
      e2e-leg-1-admintools,
      e2e-leg-2-admintools, 
      e2e-leg-3-admintools, 
      e2e-leg-4-admintools, 
      e2e-leg-4-admintools-vdb-gen, 
      e2e-leg-5-admintools, 
      e2e-server-upgrade-admintools, 
      e2e-udx-admintools
    ]
    runs-on: ubuntu-latest 
    if: ${{ always() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && contains(inputs.reason, 'server daily version') && contains(github.actor, 'verticareleng') }}  
    steps:
    - uses: actions/checkout@v4
      with:
        path: vertica-kubernetes
        fetch-depth: 0

    - name: Login to Docker Hub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}

    - name: Upload new image
      run: |
        docker buildx imagetools create --tag opentext/verticadb-operator-private:${{ github.sha }} ${{ needs.build.outputs.operator-image }}
  
  sync-vcluster:
    name: Sync-vcluster-repo
    needs: [
      e2e-leg-1-vcluster,
      e2e-leg-2-vcluster,
      e2e-leg-3-vclusterops-previous-release,
      e2e-leg-3-vcluster,
      e2e-leg-4-vcluster,
      e2e-leg-4-vcluster-vdb-gen,
      e2e-leg-5-vcluster,
      e2e-leg-6-vcluster,
      e2e-leg-6-vcluster-revivedb,
      e2e-leg-7-vcluster,
      e2e-leg-8-vcluster-offline,
      e2e-leg-8-vcluster-online,
      e2e-leg-9-vcluster,
      e2e-leg-10-vcluster,
      e2e-server-upgrade-vcluster,
      e2e-operator-upgrade,
      e2e-udx-vcluster
    ]
    runs-on: ubuntu-latest
    if: ${{ always() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && contains(github.ref, 'k8s-sync') && (github.event_name == 'push')}} 
    steps:
      - name: Check out
        uses: actions/checkout@v4
      - name: Run Sync script
        run: |
          echo "Running sync script"
          scripts/vcluster-sync.sh ${{ github.ref }} main ${{ secrets.VCLUSTER_CICD }}
  
  notification:
    name: team-notification
    needs: [sync-vcluster]
    runs-on: ubuntu-latest
    if: ${{ always() && contains(github.ref, 'k8s-sync') }}
    steps:
      - name: Get vcluster commit url
        run: |
          VCLUSTER_REF=$(echo ${{ github.event.head_commit.message }} | awk '{print $NF}')
          echo "VCLUSTER_URL=${{ github.server_url }}/vertica/vcluster/commit/$VCLUSTER_REF" >> $GITHUB_ENV

      - name: notification on success
        if: ${{ always() && contains(needs.sync-vcluster.result, 'success') }}
        uses: jdcargile/ms-teams-notification@v1.4
        with:
          github-token: ${{ github.token }}
          ms-teams-webhook-uri: ${{ secrets.MS_TEAMS_WEBHOOK_URI }}
          notification-summary: Success | worflow ${{ github.workflow }} on branch ${{ github.ref_name }} with <a href="${{ env.VCLUSTER_URL }}">VCluster commit changes</a>
          notification-color: 28a745
          verbose-logging: true

      - name: notification on failure
        if: ${{ always() && ! contains(needs.sync-vcluster.result, 'success') }}
        uses: jdcargile/ms-teams-notification@v1.4
        with:
          github-token: ${{ github.token }}
          ms-teams-webhook-uri: ${{ secrets.MS_TEAMS_WEBHOOK_URI }}
          notification-summary: Failure | worflow ${{ github.workflow }} on branch ${{ github.ref_name }} with <a href="${{ env.VCLUSTER_URL }}">VCluster commit changes</a>
          notification-color: dc3545
          verbose-logging: true