1
0
mirror of https://github.com/SAP/jenkins-library.git synced 2024-12-14 11:03:09 +02:00
sap-jenkins-library/vars/dockerExecuteOnKubernetes.groovy
Ramachandra Kamath Arbettu c84114c3df
Enable support for executing on K8S as a step (#231)
* Create executeDockerOnKubernetes.groovy

* Update dockerExecute.groovy

* Create SysEnvTest.groovy

* Update default_pipeline_environment.yml

* Update executeDockerOnKubernetes.groovy

* Create utils object

* update docker image

* Update mavenExecute.groovy

* Use pipeline-lib than piper

* Check container name

* Always change ownership to 1000

* Check for map

* Fix command

* Move chmod to docker execute

* Use generic name for the pod

* runAsPod has been added

* Return false if script has no k8smapping

* fix syntax error

* Null checks

* Returnn dockerImage name

* Check method body

* Return container name

* Cleanup echos

* Use runAsPod

* Rename step

* Use official jenkins JNLP agent image

* Construct containersMap

* Check if kubernetes plugin is active

* Support JaaS

* pass script object

* Move configuration to default section

* Use generic flag to check if running in k8s

* fix jnlp agent name

* Solve travis errors

* Improvements to config and changes to name of the method

* Improvements to config

* Fix type

* Rename stash config

* add import

* Fix map order

* Fix jnlp agent name

* cleanup config usage

* Check if config is enabled

* Use nested k8s mapping

* Support custom docker workspace and move flag to env

* Feature/k8s stage (#1)

* Use nested k8s mapping

* Support custom docker workspace and move flag to env

* Check dockerOptions value

* Support local execution

* Add tests for dockerExecute

* Move config to step and Fix tests

* Use step configuration while running as a pod

* Streamline parameter and config initialization

* Streamline parameter and tests

* Cleanup and align variable name

* Use default JNLP agent if one not defined in config

* Add tests for runInsidePod. Ensure lowercase container names.

* Improve tests and remove unused code block

* Fix permission issues

* Perform stashing and unstashing inside container

* Use custom jnlp agent due to user id restriction

* Fix tests after jnlp agent change

* Address review comments

* Initialize script to default value if null

* Address review comments

* Update exeception handling and documentation

* Improve documentation

* correct indent

* Link documents to the index page

* Merge containerExecute and dockerExecuteOnKuberenetes step and address comments.

* Update dockerExecute.md

* Update dockerExecuteOnKubernetes.md

* Update default_pipeline_environment.yml

* update documentation

* Update documentation. Use annotation for singleton

* Update DockerExecuteOnKubernetesTest.groovy

* Update dockerExecute.groovy

* Update dockerExecuteOnKubernetes.groovy

* Improve documentation and test case names

* neoDeploy: switch to chained ConfigurationHelper (#244)

* switch neoDeploy to chained ConfigurationHelper

* update imports

* Improve tests

* Address review comments

* Improve documentation

* made dockerImage non-mandatory parm, improved test

* add comment regarding userid assumption
2018-08-21 15:45:59 +02:00

170 lines
5.8 KiB
Groovy

import com.sap.piper.ConfigurationHelper
import com.sap.piper.JenkinsUtils
import com.sap.piper.k8s.SystemEnv
import groovy.transform.Field
import hudson.AbortException
@Field def STEP_NAME = 'dockerExecuteOnKubernetes'
@Field def PLUGIN_ID_KUBERNETES = 'kubernetes'
@Field Set GENERAL_CONFIG_KEYS = ['jenkinsKubernetes']
@Field Set PARAMETER_KEYS = ['dockerImage',
'dockerWorkspace',
'dockerEnvVars',
'containerMap']
@Field Set STEP_CONFIG_KEYS = PARAMETER_KEYS.plus(['stashIncludes', 'stashExcludes'])
void call(Map parameters = [:], body) {
handlePipelineStepErrors(stepName: STEP_NAME, stepParameters: parameters) {
if (!JenkinsUtils.isPluginActive(PLUGIN_ID_KUBERNETES)) {
error("[ERROR][${STEP_NAME}] not supported. Plugin '${PLUGIN_ID_KUBERNETES}' is not installed or not active.")
}
final script = parameters.script
if (script == null)
script = [commonPipelineEnvironment: commonPipelineEnvironment]
ConfigurationHelper configHelper = ConfigurationHelper
.loadStepDefaults(this)
.mixinGeneralConfig(script.commonPipelineEnvironment, GENERAL_CONFIG_KEYS)
.mixinStageConfig(script.commonPipelineEnvironment, parameters.stageName ?: env.STAGE_NAME, STEP_CONFIG_KEYS)
.mixinStepConfig(script.commonPipelineEnvironment, STEP_CONFIG_KEYS)
.mixin(parameters, PARAMETER_KEYS)
.addIfEmpty('uniqueId', UUID.randomUUID().toString())
Map config = [:]
if (parameters.containerMap) {
config = configHelper.use()
executeOnPodWithCustomContainerList(config: config) { body() }
} else {
config = configHelper
.withMandatoryProperty('dockerImage')
.use()
executeOnPodWithSingleContainer(config: config) { body() }
}
}
}
void executeOnPodWithCustomContainerList(Map parameters, body) {
def config = parameters.config
podTemplate(getOptions(config)) {
node(config.uniqueId) {
body()
}
}
}
def getOptions(config) {
return [name : 'dynamic-agent-' + config.uniqueId,
label : config.uniqueId,
containers: getContainerList(config)]
}
void executeOnPodWithSingleContainer(Map parameters, body) {
Map containerMap = [:]
def config = parameters.config
containerMap[config.get('dockerImage').toString()] = 'container-exec'
config.containerMap = containerMap
/*
* There could be exceptions thrown by
- The podTemplate
- The container method
- The body
* We use nested exception handling in this case.
* In the first 2 cases, the workspace has not been modified. Hence, we can stash existing workspace as container and
* unstash in the finally block. In case of exception thrown by the body, we need to stash the workspace from the container
* in finally block
*/
try {
stashWorkspace(config, 'workspace')
podTemplate(getOptions(config)) {
node(config.uniqueId) {
container(name: 'container-exec') {
try {
unstashWorkspace(config, 'workspace')
body()
} finally {
stashWorkspace(config, 'container')
}
}
}
}
} catch (e) {
stashWorkspace(config, 'container')
throw e
} finally {
unstashWorkspace(config, 'container')
}
}
private void stashWorkspace(config, prefix) {
try {
// Every dockerImage used in the dockerExecuteOnKubernetes should have user id 1000
sh "chown -R 1000:1000 ."
stash(
name: "${prefix}-${config.uniqueId}",
include: config.stashIncludes.workspace,
exclude: config.stashExcludes.excludes
)
} catch (AbortException | IOException e) {
echo "${e.getMessage()}"
}
}
private void unstashWorkspace(config, prefix) {
try {
unstash "${prefix}-${config.uniqueId}"
} catch (AbortException | IOException e) {
echo "${e.getMessage()}"
}
}
private List getContainerList(config) {
def envVars = getContainerEnvs(config)
result = []
result.push(containerTemplate(name: 'jnlp',
image: config.jenkinsKubernetes.jnlpAgent))
config.containerMap.each { imageName, containerName ->
result.push(containerTemplate(name: containerName.toLowerCase(),
image: imageName,
alwaysPullImage: true,
command: '/usr/bin/tail -f /dev/null',
envVars: envVars))
}
return result
}
/**
* Returns a list of envVar object consisting of set
* environment variables, params (Parametrized Build) and working directory.
* (Kubernetes-Plugin only!)
* @param config Map with configurations
*/
private List getContainerEnvs(config) {
def containerEnv = []
def dockerEnvVars = config.dockerEnvVars ?: [:]
def dockerWorkspace = config.dockerWorkspace ?: ''
if (dockerEnvVars) {
for (String k : dockerEnvVars.keySet()) {
containerEnv << envVar(key: k, value: dockerEnvVars[k].toString())
}
}
if (dockerWorkspace) {
containerEnv << envVar(key: "HOME", value: dockerWorkspace)
}
// Inherit the proxy information from the master to the container
SystemEnv systemEnv = new SystemEnv()
for (String env : systemEnv.getEnv().keySet()) {
containerEnv << envVar(key: env, value: systemEnv.get(env))
}
// ContainerEnv array can't be empty. Using a stub to avoid failure.
if (!containerEnv) {
containerEnv << envVar(key: "EMPTY_VAR", value: " ")
}
return containerEnv
}