@Library('infraLib') _

pipeline {
  agent {
    label 'linux-agents'
  }
  options { disableConcurrentBuilds() }
  environment {
    AWS_PROFILE             = "gdb-delphi-dev"
    PROJECT_GROUP           = "delphi"
    ECR                     = "475275892927.dkr.ecr.us-east-1.amazonaws.com"
    OCTOPUS_CLI_SERVER      = "https://octopus.delphi.zone"
    OCTOPUS_CLI_API_KEY     = sh(script: "aws secretsmanager get-secret-value --profile sme-dev --secret-id 'infra/jenkins/octopus_api_key' --output json | jq .SecretString | tr -d '\"'", , returnStdout: true).trim()
    OCTOPUS_CHANNEL         = octopus.setOctoChannel(env.BRANCH_NAME)
    ZIP_PACKAGE_UPLOAD_MODE = octopus.zipPackageUploadMode(params.ZIP_PACKAGE_UPLOAD_MODE)
    DEPLOY_ENV              = octopus.setDeploymentEnv(params.DEPLOY_ENV_CHOICE, env.PROJECT_GROUP, env.BRANCH_NAME )
    //NOTIFICATIONS_CHANNEL   = "delphi-chartmetrics-cicd-alerts"
  }
  parameters {
    choice(
      choices: [
        'Please make a choice',
        'chartmetric',
        'chartmetric_process_cfg',
        'chartmetric_manager',
        'chartmetric_hist_manager',
        'chartmetric_data_checker',
        'chartmetric_invoker',
        'chartmetric_migrate',
        'chartmetric_status',
        'chartmetric_api_alerts',
        'chartmetric_artist_alerts',
        'chartmetric_artist_mapping',
        'chartmetric_migrator',
        'chartmetric_snowlake',
        'sme_btutils',
        'sme_snowflake',
        'ALL'
      ],
      description: 'Force build all or some modules',
      name: 'FORCE_BUILD'
    )
    choice(
      choices: [
        'default',
        'dev',
        'qa',
        'stage',
        'skip_deployment'
      ],
      description: 'Set environment for deployment. Skipped by default master/release*, dev by default for all other branches',
      name: 'DEPLOY_ENV_CHOICE'
    )
    choice(
      choices: [
        'error',
        'overwrite',
        'skip_build'
      ],
      description: "Docker image upload mode - ovewrite if the image with such tag already exists, raise error if exists, or skip build part if exists.",
      name: 'IMAGE_UPLOAD_MODE'
    )
    choice(
      choices: [
        'no',
        'yes'
      ],
      description: "SKIP RELEASE CREATION IF RELEASE ALREADY EXISTS",
      name: 'SKIP_RELEASE_CREATION'
    )
    choice(
      choices: [
        'error',
        'overwrite',
        'ignore'
      ],
      description: 'Defines whether to raise error, overwrite or ignore if python package of specified version already exists in Pypi.',
      name: 'PYTHON_PACKAGE_UPLOAD_MODE'
    )
    choice(
      choices: [
        'error',
        'overwrite',
        'ignore'
      ],
      description: 'Defines whether to raise error, overwrite or ignore if zipPackage of specified version already exists in Octopus.',
      name: 'ZIP_PACKAGE_UPLOAD_MODE'
    )
  }
  stages {
    stage('Load shared library') {
      steps {
        script {
          library "jenkins-global-libraries@master"
        }
      }
    }
    stage("Build libraries") {
      parallel {
        stage("sme_btutils") {
          when {
            anyOf {
              allOf {
                changeset "**/sme_btutils/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'sme_btutils' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          steps {
            script {
              pythonPackage.pythonPackagePipeline(
                pythonPackage.setPythonPipelineVars("libs/sme_btutils", params.PYTHON_PACKAGE_UPLOAD_MODE )
              )
            }
          }
        }
        stage("sme_snowflake") {
          when {
            anyOf {
              allOf {
                changeset "**/sme_snowflake/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'sme_snowflake' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          steps {
            script {
              pythonPackage.pythonPackagePipeline(
                pythonPackage.setPythonPipelineVars("libs/sme_snowflake", params.PYTHON_PACKAGE_UPLOAD_MODE )
              )
            }
          }
        }
      }
    }
    stage("Build lambdas and containers") {
      parallel {
        stage("chartmetric_process_cfg") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_process_cfg/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_process_cfg' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_process_cfg",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_process_cfg",
                    env.PROJECT_GROUP, env.ECR,"lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_process_cfg",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "chartmetric",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "chartmetric", env.PROJECT_GROUP, env.ECR)
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "chartmetric",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_manager") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_manager/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_manager' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_manager",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_manager",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_manager",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_hist_manager") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_hist_manager/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_hist_manager' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_hist_manager",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_hist_manager",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_hist_manager",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_data_checker") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_data_checker/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_data_checker' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_data_checker",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_data_checker",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_data_checker",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_invoker") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_invoker/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_invoker' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_invoker",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_invoker",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_invoker",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_migrate") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_migrate/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_migrate' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_migrate",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_migrate",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_migrate",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_migrator") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_migrator/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_migrator' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "tasks/chartmetric_migrator",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "tasks/chartmetric_migrator",
                    env.PROJECT_GROUP, env.ECR)
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "tasks/chartmetric_migrator",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_status") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_status/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_status' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_status",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_status",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_status",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_api_alerts") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_api_alerts/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_api_alerts' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_api_alerts",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_api_alerts",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_api_alerts",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_artist_alerts") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_artist_alerts/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_artist_alerts' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_artist_alerts",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_artist_alerts",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_artist_alerts",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage("chartmetric_artist_mapping") {
          when {
            anyOf {
              allOf {
                changeset "**/chartmetric_artist_mapping/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'chartmetric_artist_mapping' }
              expression { return params.FORCE_BUILD == 'ALL' }
            }
          }
          stages {
            stage('Validate Software Catalog Definition') {
              steps {
                script {
                  datadogSoftwareCatalogValidate(
                    servicePath: "lambdas/chartmetric_artist_mapping",
                  )
                }
              }
            }
            stage('Deploy') {
              steps {
                script {
                  pythonPackage.dockerPipeline(pythonPackage.setDockerPipelineParams(
                    params.IMAGE_UPLOAD_MODE,
                    params.SKIP_RELEASE_CREATION,
                    "lambdas/chartmetric_artist_mapping",
                    env.PROJECT_GROUP, env.ECR, "lambda")
                  )
                }
              }
            }
            stage('Publish Software Catalog Definition') {
              when {
                branch 'master'
              }
              steps {
                script {
                  datadogSoftwareCatalogPublish(
                    servicePath: "lambdas/chartmetric_artist_mapping",
                    fetchAdditionalMetadata: false
                  )
                }
              }
            }
          }
        }
        stage('chartmetric_snowlake') {
          when {
            anyOf {
              allOf {
                changeset "**/step_function/chartmetric_snowflake/**"
                expression { return params.FORCE_BUILD == 'Please make a choice' }
              }
              expression { return params.FORCE_BUILD == 'ALL' || params.FORCE_BUILD == 'chartmetric_snowlake' }
            }
          }
          steps {
            script {
              parameters = zipPackage.setZipPackagePipelineParams(params.SKIP_RELEASE_CREATION, "step_function/chartmetric_snowflake", env.PROJECT_GROUP)
              zipPackage.zipPackagePipeline(parameters)
            }
          }
        }
      }
    }    
  }
  post {
    always {
      sh "sudo chown -R ec2-user:ec2-user ${env.WORKSPACE}"
    }
    /*success {
      script {
        if (currentBuild.getPreviousBuild() &&
            currentBuild.getPreviousBuild().getResult().toString() != "SUCCESS") {
          utility.slackNotifyMainBranches(currentBuild.currentResult, env.NOTIFICATIONS_CHANNEL)
        }
      }
    }
    failure {
      script {
        utility.slackNotifyMainBranches(currentBuild.currentResult, env.NOTIFICATIONS_CHANNEL)
      }
    }*/
    cleanup {
        deleteDir()
    }
  }
}