sap-jenkins-library/vars/multicloudDeploy.groovy

import com.sap.piper.GenerateDocumentation
import com.sap.piper.CloudPlatform
import com.sap.piper.DeploymentType
import com.sap.piper.ConfigurationHelper
import com.sap.piper.Utils
import com.sap.piper.JenkinsUtils
import com.sap.piper.k8s.ContainerMap

import groovy.transform.Field

import static com.sap.piper.Prerequisites.checkScript

@Field String STEP_NAME = getClass().getName()

@Field Set GENERAL_CONFIG_KEYS = [
    /** Defines the targets to deploy on Cloud Foundry.*/
    'cfTargets',
    /** Defines the targets to deploy on neo.*/
    'neoTargets',
    /** Executes the deployments in parallel.*/
    'parallelExecution'
]

@Field Set STEP_CONFIG_KEYS = GENERAL_CONFIG_KEYS.plus([
    /**
     * Defines Cloud Foundry service instances to create as part of the deployment.
     * This is a _list_ of _objects_ with the following properties each:
     * - apiEndpoint
     * - credentialsId
     * - serviceManifest
     * - manifestVariablesFiles
     * - org
     * - space
     */
    'cfCreateServices',
    /** Defines the deployment type.*/
    'enableZeroDowntimeDeployment',
])

@Field Set PARAMETER_KEYS = STEP_CONFIG_KEYS.plus([
    /** The source file to deploy to SAP BTP.*/
    'source',
    /** Closure which is executed before calling the deployment steps.*/
    'preDeploymentHook'
])

@Field Map CONFIG_KEY_COMPATIBILITY = [parallelExecution: 'features/parallelTestExecution']

/**
 * Deploys an application to multiple platforms (Cloud Foundry, SAP BTP) or to multiple instances of multiple platforms or the same platform.
 */
@GenerateDocumentation
void call(parameters = [:]) {

    handlePipelineStepErrors(stepName: STEP_NAME, stepParameters: parameters) {

        def script = checkScript(this, parameters) ?: this
        def utils = parameters.utils ?: new Utils()
        def jenkinsUtils = parameters.jenkinsUtils ?: new JenkinsUtils()
        String stageName = parameters.stage ?: env.STAGE_NAME

        ConfigurationHelper configHelper = ConfigurationHelper.newInstance(this)
            .loadStepDefaults([:], stageName)
            .mixinGeneralConfig(script.commonPipelineEnvironment, GENERAL_CONFIG_KEYS, CONFIG_KEY_COMPATIBILITY)
            .mixinStepConfig(script.commonPipelineEnvironment, STEP_CONFIG_KEYS, CONFIG_KEY_COMPATIBILITY)
            .mixinStageConfig(script.commonPipelineEnvironment, stageName, STEP_CONFIG_KEYS, CONFIG_KEY_COMPATIBILITY)
            .mixin(parameters, PARAMETER_KEYS)

        Map config = configHelper.use()

        utils.pushToSWA([
            step         : STEP_NAME,
            stepParamKey1: 'enableZeroDowntimeDeployment',
            stepParam1   : config.enableZeroDowntimeDeployment
        ], config)

        def index = 1
        def deployments = [:]

        if (config.cfCreateServices) {
            def createServices = [:]
            for (int i = 0; i < config.cfCreateServices.size(); i++) {
                Map createServicesConfig = config.cfCreateServices[i]
                createServices["Service Creation ${i + 1}"] = {
                    cloudFoundryCreateService(
                        script: script,
                        cloudFoundry: [
                            apiEndpoint           : createServicesConfig.apiEndpoint,
                            credentialsId         : createServicesConfig.credentialsId,
                            serviceManifest       : createServicesConfig.serviceManifest,
                            manifestVariablesFiles: createServicesConfig.manifestVariablesFiles,
                            org                   : createServicesConfig.org,
                            space                 : createServicesConfig.space
                        ]
                    )
                }
            }
            runClosures(script, createServices, config.parallelExecution, "cloudFoundryCreateService")
        }

        if (config.cfTargets) {

            def deploymentType = DeploymentType.selectFor(CloudPlatform.CLOUD_FOUNDRY, config.enableZeroDowntimeDeployment).toString()

            // An isolated workspace is required when using blue-green deployment with multiple cfTargets,
            // since the cloudFoundryDeploy step might edit the manifest.yml file in that case.
            // It is also required in case of parallel execution and use of mtaExtensionCredentials, since the
            // credentials are inserted in the mtaExtensionDescriptor file.
            Boolean runInIsolatedWorkspace = config.cfTargets.size() > 1 && (deploymentType == "blue-green" || config.parallelExecution)

            for (int i = 0; i < config.cfTargets.size(); i++) {

                def target = config.cfTargets[i]

                Closure deployment = {
                    Utils deploymentUtils = new Utils()
                    if (runInIsolatedWorkspace) {
                        deploymentUtils.unstashStageFiles(script, stageName)
                    }

                    if (config.preDeploymentHook) {
                        config.preDeploymentHook.call()
                    }

                    cloudFoundryDeploy(
                        script: script,
                        juStabUtils: utils,
                        jenkinsUtilsStub: jenkinsUtils,
                        deployType: deploymentType,
                        cloudFoundry: target,
                        mtaExtensionDescriptor: target.mtaExtensionDescriptor,
                        mtaExtensionCredentials: target.mtaExtensionCredentials
                    )
                    if (runInIsolatedWorkspace) {
                        deploymentUtils.stashStageFiles(script, stageName)
                    }
                }
                if (runInIsolatedWorkspace){
                    deployments["Deployment ${index}"] = {
                        if (env.POD_NAME) {
                            dockerExecuteOnKubernetes(script: script, containerMap: ContainerMap.instance.getMap().get(stageName) ?: [:]) {
                                deployment.call()
                            }
                        } else {
                            node(env.NODE_NAME) {
                                deployment.call()
                            }
                        }
                    }
                } else {
                    deployments.put("Deployment ${index}", deployment)
                }
                index++
            }
        }

        if (config.neoTargets) {

            def deploymentType = DeploymentType.selectFor(CloudPlatform.NEO, config.enableZeroDowntimeDeployment).toString()

            for (int i = 0; i < config.neoTargets.size(); i++) {

                def target = config.neoTargets[i]

                Closure deployment = {
                    if (config.preDeploymentHook) {
                        config.preDeploymentHook.call()
                    }

                    neoDeploy(
                        script: script,
                        warAction: deploymentType,
                        source: config.source,
                        neo: target
                    )

                }
                deployments.put("Deployment ${index}", deployment)
                index++
            }
        }

        if (!config.cfTargets && !config.neoTargets) {
            error "Deployment skipped because no targets defined!"
        }

        runClosures(script, deployments, config.parallelExecution, "deployments")
    }
}