Jenkinsfile

@Library('podTemplateLib')
import net.santiment.utils.podTemplates
import java.util.UUID

properties([
  buildDiscarder(
    logRotator(artifactDaysToKeepStr: '30',
    artifactNumToKeepStr: '',
    daysToKeepStr: '30',
    numToKeepStr: ''))
  ])

slaveTemplates = new podTemplates()

def numPartitions = 4

slaveTemplates.dockerTemplate { label ->
  node(label) {
    stage('Build Test Image') {
      container('docker') {
        def scmVars = checkout scm
        def gitHead = scmVars.GIT_COMMIT.substring(0, 7)
        def sanitizedBranchName = env.BRANCH_NAME.replaceAll('/', '-')
        def changeId = env.CHANGE_ID ?: 'none'
        def imageTag = "sanbase-test:${scmVars.GIT_COMMIT}-${env.BUILD_ID}-${sanitizedBranchName}-${changeId}"

        sh "docker build \
          -t ${imageTag} \
          -f Dockerfile-test . \
          --progress plain"

        // Store variables for later stages
        env.TEST_IMAGE_TAG = imageTag
        env.GIT_HEAD = gitHead
        env.GIT_COMMIT_FULL = scmVars.GIT_COMMIT
      }
    }

    stage('Run Tests') {
      container('docker') {
        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
          def imageTag = env.TEST_IMAGE_TAG
          def runToken = UUID.randomUUID().toString().substring(0, 8)
          def buildSuffix = "${env.GIT_COMMIT_FULL}-${env.BUILD_ID}-${runToken}"
          def networkName = "test-net-${buildSuffix}"
          env.TEST_RUN_SUFFIX = buildSuffix
          def failuresDir = "${pwd()}/test_failures_${buildSuffix}"

          sh "mkdir -p ${failuresDir}"
          sh "docker network create ${networkName} >/dev/null 2>&1 || true"

          for (int i = 1; i <= numPartitions; i++) {
            def postgresContainerName = "test-postgres-${buildSuffix}-p${i}"
            sh "docker rm -f ${postgresContainerName} >/dev/null 2>&1 || true"
            sh "docker run \
              --rm --name ${postgresContainerName} \
              --network ${networkName} \
              --network-alias test-db-p${i} \
              -e POSTGRES_PASSWORD=password \
              --health-cmd 'pg_isready -U postgres' \
              --health-interval 2s \
              --health-timeout 5s \
              --health-retries 10 \
              -d pgvector/pgvector:pg17"
          }

          sh """
            set -e
            for i in \$(seq 1 ${numPartitions}); do
              name="test-postgres-${buildSuffix}-p\$i"
              echo "Waiting for \$name to be ready..."
              for attempt in \$(seq 1 30); do
                if docker exec "\$name" pg_isready -U postgres 2>/dev/null; then
                  echo "\$name is ready"
                  break
                fi
                if [ \$attempt -eq 30 ]; then
                  echo "ERROR: \$name did not become ready within 60 seconds"
                  docker logs "\$name" 2>&1 || true
                  exit 1
                fi
                sleep 2
              done
            done
          """

          try {
            def partitions = [:]
            for (int i = 1; i <= numPartitions; i++) {
              def partition = i
              def dbHost = "test-db-p${partition}"
              partitions["Partition ${partition}"] = {
                sh "docker run --rm \
                  --network ${networkName} \
                  --env DATABASE_URL=postgres://postgres:password@${dbHost}:5432/postgres \
                  --env MIX_TEST_PARTITION=${partition} \
                  -v ${failuresDir}:/app/_build/test/failures \
                  -t ${imageTag} \
                  mix test --partitions ${numPartitions} \
                    --formatter Sanbase.FailedTestFormatter \
                    --formatter ExUnit.CLIFormatter \
                    --slowest 20"
              }
            }

            timeout(time: 25, unit: 'MINUTES') {
              parallel partitions
            }
          } finally {
            sh """
              for i in \$(seq 1 ${numPartitions}); do
                docker rm -f test-postgres-${buildSuffix}-p\$i 2>/dev/null || true
              done
              docker network rm ${networkName} 2>/dev/null || true
            """
          }
        }
      }
    }

    stage('Summarize Test Failures') {
      container('docker') {
        def buildSuffix = env.TEST_RUN_SUFFIX ?: "${env.GIT_COMMIT_FULL}-${env.BUILD_ID}"
        def failuresDir = "${pwd()}/test_failures_${buildSuffix}"

        sh """
          set +x
          echo ''
          echo '========================================'
          echo '  Combined results from all partitions'
          echo '========================================'

          if ls ${failuresDir}/partition_*.txt 1>/dev/null 2>&1; then
            echo 'Failing tests across all partitions:'
            cut -f2 ${failuresDir}/partition_*.txt | sort
            echo ''
            echo 'Re-run with:'
            echo "  mix test \$(cut -f2 ${failuresDir}/partition_*.txt | tr '\\n' ' ')"
            rm -rf ${failuresDir}
            exit 1
          fi

          echo 'All partitions passed!'
          rm -rf ${failuresDir}
        """
      }
    }

    if (env.BRANCH_NAME == 'master') {
      stage('Build & Push') {
        container('docker') {
          withCredentials([
            string(
              credentialsId: 'SECRET_KEY_BASE',
              variable: 'SECRET_KEY_BASE'
            ),
            string(
              credentialsId: 'PARITY_URL',
              variable: 'PARITY_URL'
            ),
            string(
              credentialsId: 'aws_account_id',
              variable: 'aws_account_id'
            )
          ]) {
            def awsRegistry = "${env.aws_account_id}.dkr.ecr.eu-central-1.amazonaws.com"
            docker.withRegistry("https://${awsRegistry}", 'ecr:eu-central-1:ecr-credentials') {
              sh "docker build \
                -t ${awsRegistry}/sanbase:${env.BRANCH_NAME} \
                -t ${awsRegistry}/sanbase:${env.GIT_COMMIT_FULL} \
                --build-arg SECRET_KEY_BASE=${env.SECRET_KEY_BASE} \
                --build-arg PARITY_URL=${env.PARITY_URL} \
                --build-arg GIT_HEAD=${env.GIT_HEAD} \
                --build-arg GIT_COMMIT=${env.GIT_COMMIT_FULL} . \
                --progress plain"

              sh "docker push ${awsRegistry}/sanbase:${env.BRANCH_NAME}"
              sh "docker push ${awsRegistry}/sanbase:${env.GIT_COMMIT_FULL}"
            }
          }
        }
      }
    }
  }
}