src/com/mirantis/mk/Common.groovy - mcp-ci/pipeline-library - Gitiles

 package com.mirantis.mk

 import static groovy.json.JsonOutput.prettyPrint
 import static groovy.json.JsonOutput.toJson

 import com.cloudbees.groovy.cps.NonCPS
 import groovy.json.JsonSlurperClassic

 /**
  *
  * Common functions
  *
  */

 /**
  * Generate current timestamp
  *
  * @param format Defaults to yyyyMMddHHmmss
  */
 def getDatetime(format = "yyyyMMddHHmmss") {
     def now = new Date();
     return now.format(format, TimeZone.getTimeZone('UTC'));
 }

 /**
  * Return workspace.
  * Currently implemented by calling pwd so it won't return relevant result in
  * dir context
  */
 def getWorkspace(includeBuildNum = false) {
     def workspace = sh script: 'pwd', returnStdout: true
     workspace = workspace.trim()
     if (includeBuildNum) {
         if (!workspace.endsWith("/")) {
             workspace += "/"
         }
         workspace += env.BUILD_NUMBER
     }
     return workspace
 }

 /**
  * Get UID of jenkins user.
  * Must be run from context of node
  */
 def getJenkinsUid() {
     return sh(
         script: 'id -u',
         returnStdout: true
     ).trim()
 }

 /**
  * Get GID of jenkins user.
  * Must be run from context of node
  */
 def getJenkinsGid() {
     return sh(
         script: 'id -g',
         returnStdout: true
     ).trim()
 }

 /**
  * Returns Jenkins user uid and gid in one list (in that order)
  * Must be run from context of node
  */
 def getJenkinsUserIds() {
     return sh(script: "id -u && id -g", returnStdout: true).tokenize("\n")
 }

 /**
  *
  * Find credentials by ID
  *
  * @param credsId Credentials ID
  * @param credsType Credentials type (optional)
  *
  */
 def getCredentialsById(String credsId, String credsType = 'any') {
     def credClasses = [ // ordered by class name
                         sshKey    : com.cloudbees.jenkins.plugins.sshcredentials.impl.BasicSSHUserPrivateKey.class,
                         cert      : com.cloudbees.plugins.credentials.common.CertificateCredentials.class,
                         password  : com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials.class,
                         any       : com.cloudbees.plugins.credentials.impl.BaseStandardCredentials.class,
                         dockerCert: org.jenkinsci.plugins.docker.commons.credentials.DockerServerCredentials.class,
                         file      : org.jenkinsci.plugins.plaincredentials.FileCredentials.class,
                         string    : org.jenkinsci.plugins.plaincredentials.StringCredentials.class,
     ]
     return com.cloudbees.plugins.credentials.CredentialsProvider.lookupCredentials(
         credClasses[credsType],
         jenkins.model.Jenkins.instance
     ).findAll { cred -> cred.id == credsId }[0]
 }

 /**
  * Get credentials from store
  *
  * @param id Credentials name
  */
 def getCredentials(id, cred_type = "username_password") {
     warningMsg('You are using obsolete function. Please switch to use `getCredentialsById()`')

     type_map = [
         username_password: 'password',
         key              : 'sshKey',
     ]

     return getCredentialsById(id, type_map[cred_type])
 }

 /**
  * Abort build, wait for some time and ensure we will terminate
  */
 def abortBuild() {
     currentBuild.build().doStop()
     sleep(180)
     // just to be sure we will terminate
     throw new InterruptedException()
 }

 /**
  * Print pretty-printed string representation of given item
  * @param item item to be pretty-printed (list, map, whatever)
  */
 def prettyPrint(item) {
     println prettify(item)
 }

 /**
  * Return pretty-printed string representation of given item
  * @param item item to be pretty-printed (list, map, whatever)
  * @return pretty-printed string
  */
 def prettify(item) {
     return groovy.json.JsonOutput.prettyPrint(toJson(item)).replace('\\n', System.getProperty('line.separator'))
 }

 /**
  * Print informational message
  *
  * @param msg
  * @param color Colorful output or not
  */
 def infoMsg(msg, color = true) {
     printMsg(msg, "cyan")
 }

 /**
  * Print error message
  *
  * @param msg
  * @param color Colorful output or not
  */
 def errorMsg(msg, color = true) {
     printMsg(msg, "red")
 }

 /**
  * Print success message
  *
  * @param msg
  * @param color Colorful output or not
  */
 def successMsg(msg, color = true) {
     printMsg(msg, "green")
 }

 /**
  * Print warning message
  *
  * @param msg
  * @param color Colorful output or not
  */
 def warningMsg(msg, color = true) {
     printMsg(msg, "yellow")
 }

 /**
  * Print debug message, this message will show only if DEBUG global variable is present
  * @param msg
  * @param color Colorful output or not
  */
 def debugMsg(msg, color = true) {
     // if debug property exists on env, debug is enabled
     if (env.getEnvironment().containsKey('DEBUG') && env['DEBUG'] == "true") {
         printMsg("[DEBUG] ${msg}", "red")
     }
 }

 /**
  * Print message
  *
  * @param msg Message to be printed
  * @param level Level of message (default INFO)
  * @param color Color to use for output or false (default)
  */
 def printMsg(msg, color = false) {
     colors = [
         'red'   : '\u001B[31m',
         'black' : '\u001B[30m',
         'green' : '\u001B[32m',
         'yellow': '\u001B[33m',
         'blue'  : '\u001B[34m',
         'purple': '\u001B[35m',
         'cyan'  : '\u001B[36m',
         'white' : '\u001B[37m',
         'reset' : '\u001B[0m'
     ]
     if (color != false) {
         print "${colors[color]}${msg}${colors.reset}"
     } else {
         print "[${level}] ${msg}"
     }
 }

 /**
  * Traverse directory structure and return list of files
  *
  * @param path Path to search
  * @param type Type of files to search (groovy.io.FileType.FILES)
  */
 @NonCPS
 def getFiles(path, type = groovy.io.FileType.FILES) {
     files = []
     new File(path).eachFile(type) {
         files[] = it
     }
     return files
 }

 /**
  * Helper method to convert map into form of list of [key,value] to avoid
  * unserializable exceptions
  *
  * @param m Map
  */
 @NonCPS
 def entries(m) {
     m.collect { k, v -> [k, v] }
 }

 /**
  * Opposite of build-in parallel, run map of steps in serial
  *
  * @param steps Map of String<name>: CPSClosure2<step> (or list of closures)
  */
 def serial(steps) {
     stepsArray = entries(steps)
     for (i = 0; i < stepsArray.size; i++) {
         def step = stepsArray[i]
         def dummySteps = [:]
         def stepKey
         if (step[1] instanceof List || step[1] instanceof Map) {
             for (j = 0; j < step[1].size(); j++) {
                 if (step[1] instanceof List) {
                     stepKey = j
                 } else if (step[1] instanceof Map) {
                     stepKey = step[1].keySet()[j]
                 }
                 dummySteps.put("step-${step[0]}-${stepKey}", step[1][stepKey])
             }
         } else {
             dummySteps.put(step[0], step[1])
         }
         parallel dummySteps
     }
 }

 /**
  * Partition given list to list of small lists
  * @param inputList input list
  * @param partitionSize (partition size, optional, default 5)
  */
 def partitionList(inputList, partitionSize = 5) {
     List<List<String>> partitions = new ArrayList<>();
     for (int i = 0; i < inputList.size(); i += partitionSize) {
         partitions.add(new ArrayList<String>(inputList.subList(i, Math.min(i + partitionSize, inputList.size()))));
     }
     return partitions
 }

 /**
  * Get password credentials from store
  *
  * @param id Credentials name
  */
 def getPasswordCredentials(id) {
     return getCredentialsById(id, 'password')
 }

 /**
  * Get SSH credentials from store
  *
  * @param id Credentials name
  */
 def getSshCredentials(id) {
     return getCredentialsById(id, 'sshKey')
 }

 /**
  * Tests Jenkins instance for existence of plugin with given name
  * @param pluginName plugin short name to test
  * @return boolean result
  */
 @NonCPS
 def jenkinsHasPlugin(pluginName) {
     return Jenkins.instance.pluginManager.plugins.collect { p -> p.shortName }.contains(pluginName)
 }

 @NonCPS
 def _needNotification(notificatedTypes, buildStatus, jobName) {
     if (notificatedTypes && notificatedTypes.contains("onchange")) {
         if (jobName) {
             def job = Jenkins.instance.getItem(jobName)
             def numbuilds = job.builds.size()
             if (numbuilds > 0) {
                 //actual build is first for some reasons, so last finished build is second
                 def lastBuild = job.builds[1]
                 if (lastBuild) {
                     if (lastBuild.result.toString().toLowerCase().equals(buildStatus)) {
                         println("Build status didn't changed since last build, not sending notifications")
                         return false;
                     }
                 }
             }
         }
     } else if (!notificatedTypes.contains(buildStatus)) {
         return false;
     }
     return true;
 }

 /**
  * Send notification to all enabled notifications services
  * @param buildStatus message type (success, warning, error), null means SUCCESSFUL
  * @param msgText message text
  * @param enabledNotifications list of enabled notification types, types: slack, hipchat, email, default empty
  * @param notificatedTypes types of notifications will be sent, default onchange - notificate if current build result not equal last result;
  *                         otherwise use - ["success","unstable","failed"]
  * @param jobName optional job name param, if empty env.JOB_NAME will be used
  * @param buildNumber build number param, if empty env.BUILD_NUM will be used
  * @param buildUrl build url param, if empty env.BUILD_URL will be used
  * @param mailFrom mail FROM param, if empty "jenkins" will be used, it's mandatory for sending email notifications
  * @param mailTo mail TO param, it's mandatory for sending email notifications, this option enable mail notification
  */
 def sendNotification(buildStatus, msgText = "", enabledNotifications = [], notificatedTypes = ["onchange"], jobName = null, buildNumber = null, buildUrl = null, mailFrom = "jenkins", mailTo = null) {
     // Default values
     def colorName = 'blue'
     def colorCode = '#0000FF'
     def buildStatusParam = buildStatus != null && buildStatus != "" ? buildStatus : "SUCCESS"
     def jobNameParam = jobName != null && jobName != "" ? jobName : env.JOB_NAME
     def buildNumberParam = buildNumber != null && buildNumber != "" ? buildNumber : env.BUILD_NUMBER
     def buildUrlParam = buildUrl != null && buildUrl != "" ? buildUrl : env.BUILD_URL
     def subject = "${buildStatusParam}: Job '${jobNameParam} [${buildNumberParam}]'"
     def summary = "${subject} (${buildUrlParam})"

     if (msgText != null && msgText != "") {
         summary += "\n${msgText}"
     }
     if (buildStatusParam.toLowerCase().equals("success")) {
         colorCode = "#00FF00"
         colorName = "green"
     } else if (buildStatusParam.toLowerCase().equals("unstable")) {
         colorCode = "#FFFF00"
         colorName = "yellow"
     } else if (buildStatusParam.toLowerCase().equals("failure")) {
         colorCode = "#FF0000"
         colorName = "red"
     }
     if (_needNotification(notificatedTypes, buildStatusParam.toLowerCase(), jobNameParam)) {
         if (enabledNotifications.contains("slack") && jenkinsHasPlugin("slack")) {
             try {
                 slackSend color: colorCode, message: summary
             } catch (Exception e) {
                 println("Calling slack plugin failed")
                 e.printStackTrace()
             }
         }
         if (enabledNotifications.contains("hipchat") && jenkinsHasPlugin("hipchat")) {
             try {
                 hipchatSend color: colorName.toUpperCase(), message: summary
             } catch (Exception e) {
                 println("Calling hipchat plugin failed")
                 e.printStackTrace()
             }
         }
         if (enabledNotifications.contains("email") && mailTo != null && mailTo != "" && mailFrom != null && mailFrom != "") {
             try {
                 mail body: summary, from: mailFrom, subject: subject, to: mailTo
             } catch (Exception e) {
                 println("Sending mail plugin failed")
                 e.printStackTrace()
             }
         }
     }
 }

 /**
  * Execute linux command and catch nth element
  * @param cmd command to execute
  * @param index index to retrieve
  * @return index-th element
  */

 def cutOrDie(cmd, index) {
     def common = new com.mirantis.mk.Common()
     def output
     try {
         output = sh(script: cmd, returnStdout: true)
         def result = output.tokenize(" ")[index]
         return result;
     } catch (Exception e) {
         common.errorMsg("Failed to execute cmd: ${cmd}\n output: ${output}")
     }
 }

 /**
  * Check variable contains keyword
  * @param variable keywork is searched (contains) here
  * @param keyword string to look for
  * @return True if variable contains keyword (case insensitive), False if do not contains or any of input isn't a string
  */

 def checkContains(variable, keyword) {
     if (env.getEnvironment().containsKey(variable)) {
         return env[variable] && env[variable].toLowerCase().contains(keyword.toLowerCase())
     } else {
         return false
     }
 }

 /**
  * Parse JSON string to hashmap
  * @param jsonString input JSON string
  * @return created hashmap
  */
 def parseJSON(jsonString) {
     def m = [:]
     def lazyMap = new JsonSlurperClassic().parseText(jsonString)
     m.putAll(lazyMap)
     return m
 }

 /**
  * Test pipeline input parameter existence and validity (not null and not empty string)
  * @param paramName input parameter name (usually uppercase)
  */
 def validInputParam(paramName) {
     return env.getEnvironment().containsKey(paramName) && env[paramName] != null && env[paramName] != ""
 }

 /**
  * Take list of hashmaps and count number of hashmaps with parameter equals eq
  * @param lm list of hashmaps
  * @param param define parameter of hashmap to read and compare
  * @param eq desired value of hashmap parameter
  * @return count of hashmaps meeting defined condition
  */

 @NonCPS
 def countHashMapEquals(lm, param, eq) {
     return lm.stream().filter { i -> i[param].equals(eq) }.collect(java.util.stream.Collectors.counting())
 }

 /**
  * Execute shell command and return stdout, stderr and status
  *
  * @param cmd Command to execute
  * @return map with stdout, stderr, status keys
  */

 def shCmdStatus(cmd) {
     def res = [:]
     def stderr = sh(script: 'mktemp', returnStdout: true).trim()
     def stdout = sh(script: 'mktemp', returnStdout: true).trim()

     try {
         def status = sh(script: "${cmd} 1>${stdout} 2>${stderr}", returnStatus: true)
         res['stderr'] = sh(script: "cat ${stderr}", returnStdout: true)
         res['stdout'] = sh(script: "cat ${stdout}", returnStdout: true)
         res['status'] = status
     } finally {
         sh(script: "rm ${stderr}", returnStdout: true)
         sh(script: "rm ${stdout}", returnStdout: true)
     }

     return res
 }

 /**
  * Retry commands passed to body
  *
  * @param times Number of retries
  * @param delay Delay between retries (in seconds)
  * @param body Commands to be in retry block
  * @return calling commands in body
  * @example retry ( 3 , 5 ) { function body }*          retry{ function body }
  */

 def retry(int times = 5, int delay = 0, Closure body) {
     int retries = 0
     def exceptions = []
     while (retries++ < times) {
         try {
             return body.call()
         } catch (e) {
             sleep(delay)
         }
     }
     currentBuild.result = "FAILURE"
     throw new Exception("Failed after $times retries")
 }

 /**
  * Wait for user input with timeout
  *
  * @param timeoutInSeconds Timeout
  * @param options Options for input widget
  */
 def waitForInputThenPass(timeoutInSeconds, options = [message: 'Ready to go?']) {
     def userInput = true
     try {
         timeout(time: timeoutInSeconds, unit: 'SECONDS') {
             userInput = input options
         }
     } catch (err) { // timeout reached or input false
         def user = err.getCauses()[0].getUser()
         if ('SYSTEM' == user.toString()) { // SYSTEM means timeout.
             println("Timeout, proceeding")
         } else {
             userInput = false
             println("Aborted by: [${user}]")
             throw err
         }
     }
     return userInput
 }

 /**
  * Function receives Map variable as input and sorts it
  * by values ascending. Returns sorted Map
  * @param _map Map variable
  */
 @NonCPS
 def SortMapByValueAsc(_map) {
     def sortedMap = _map.sort { it.value }
     return sortedMap
 }
	package com.mirantis.mk

	import static groovy.json.JsonOutput.prettyPrint
	import static groovy.json.JsonOutput.toJson

	import com.cloudbees.groovy.cps.NonCPS
	import groovy.json.JsonSlurperClassic

	/**
	*
	* Common functions
	*
	*/

	/**
	* Generate current timestamp
	*
	* @param format Defaults to yyyyMMddHHmmss
	*/
	def getDatetime(format = "yyyyMMddHHmmss") {
	def now = new Date();
	return now.format(format, TimeZone.getTimeZone('UTC'));
	}

	/**
	* Return workspace.
	* Currently implemented by calling pwd so it won't return relevant result in
	* dir context
	*/
	def getWorkspace(includeBuildNum = false) {
	def workspace = sh script: 'pwd', returnStdout: true
	workspace = workspace.trim()
	if (includeBuildNum) {
	if (!workspace.endsWith("/")) {
	workspace += "/"
	}
	workspace += env.BUILD_NUMBER
	}
	return workspace
	}

	/**
	* Get UID of jenkins user.
	* Must be run from context of node
	*/
	def getJenkinsUid() {
	return sh(
	script: 'id -u',
	returnStdout: true
	).trim()
	}

	/**
	* Get GID of jenkins user.
	* Must be run from context of node
	*/
	def getJenkinsGid() {
	return sh(
	script: 'id -g',
	returnStdout: true
	).trim()
	}

	/**
	* Returns Jenkins user uid and gid in one list (in that order)
	* Must be run from context of node
	*/
	def getJenkinsUserIds() {
	return sh(script: "id -u && id -g", returnStdout: true).tokenize("\n")
	}

	/**
	*
	* Find credentials by ID
	*
	* @param credsId Credentials ID
	* @param credsType Credentials type (optional)
	*
	*/
	def getCredentialsById(String credsId, String credsType = 'any') {
	def credClasses = [ // ordered by class name
	sshKey : com.cloudbees.jenkins.plugins.sshcredentials.impl.BasicSSHUserPrivateKey.class,
	cert : com.cloudbees.plugins.credentials.common.CertificateCredentials.class,
	password : com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials.class,
	any : com.cloudbees.plugins.credentials.impl.BaseStandardCredentials.class,
	dockerCert: org.jenkinsci.plugins.docker.commons.credentials.DockerServerCredentials.class,
	file : org.jenkinsci.plugins.plaincredentials.FileCredentials.class,
	string : org.jenkinsci.plugins.plaincredentials.StringCredentials.class,
	]
	return com.cloudbees.plugins.credentials.CredentialsProvider.lookupCredentials(
	credClasses[credsType],
	jenkins.model.Jenkins.instance
	).findAll { cred -> cred.id == credsId }[0]
	}

	/**
	* Get credentials from store
	*
	* @param id Credentials name
	*/
	def getCredentials(id, cred_type = "username_password") {
	warningMsg('You are using obsolete function. Please switch to use `getCredentialsById()`')

	type_map = [
	username_password: 'password',
	key : 'sshKey',
	]

	return getCredentialsById(id, type_map[cred_type])
	}

	/**
	* Abort build, wait for some time and ensure we will terminate
	*/
	def abortBuild() {
	currentBuild.build().doStop()
	sleep(180)
	// just to be sure we will terminate
	throw new InterruptedException()
	}

	/**
	* Print pretty-printed string representation of given item
	* @param item item to be pretty-printed (list, map, whatever)
	*/
	def prettyPrint(item) {
	println prettify(item)
	}

	/**
	* Return pretty-printed string representation of given item
	* @param item item to be pretty-printed (list, map, whatever)
	* @return pretty-printed string
	*/
	def prettify(item) {
	return groovy.json.JsonOutput.prettyPrint(toJson(item)).replace('\\n', System.getProperty('line.separator'))
	}

	/**
	* Print informational message
	*
	* @param msg
	* @param color Colorful output or not
	*/
	def infoMsg(msg, color = true) {
	printMsg(msg, "cyan")
	}

	/**
	* Print error message
	*
	* @param msg
	* @param color Colorful output or not
	*/
	def errorMsg(msg, color = true) {
	printMsg(msg, "red")
	}

	/**
	* Print success message
	*
	* @param msg
	* @param color Colorful output or not
	*/
	def successMsg(msg, color = true) {
	printMsg(msg, "green")
	}

	/**
	* Print warning message
	*
	* @param msg
	* @param color Colorful output or not
	*/
	def warningMsg(msg, color = true) {
	printMsg(msg, "yellow")
	}

	/**
	* Print debug message, this message will show only if DEBUG global variable is present
	* @param msg
	* @param color Colorful output or not
	*/
	def debugMsg(msg, color = true) {
	// if debug property exists on env, debug is enabled
	if (env.getEnvironment().containsKey('DEBUG') && env['DEBUG'] == "true") {
	printMsg("[DEBUG] ${msg}", "red")
	}
	}

	/**
	* Print message
	*
	* @param msg Message to be printed
	* @param level Level of message (default INFO)
	* @param color Color to use for output or false (default)
	*/
	def printMsg(msg, color = false) {
	colors = [
	'red' : '\u001B[31m',
	'black' : '\u001B[30m',
	'green' : '\u001B[32m',
	'yellow': '\u001B[33m',
	'blue' : '\u001B[34m',
	'purple': '\u001B[35m',
	'cyan' : '\u001B[36m',
	'white' : '\u001B[37m',
	'reset' : '\u001B[0m'
	]
	if (color != false) {
	print "${colors[color]}${msg}${colors.reset}"
	} else {
	print "[${level}] ${msg}"
	}
	}

	/**
	* Traverse directory structure and return list of files
	*
	* @param path Path to search
	* @param type Type of files to search (groovy.io.FileType.FILES)
	*/
	@NonCPS
	def getFiles(path, type = groovy.io.FileType.FILES) {
	files = []
	new File(path).eachFile(type) {
	files[] = it
	}
	return files
	}

	/**
	* Helper method to convert map into form of list of [key,value] to avoid
	* unserializable exceptions
	*
	* @param m Map
	*/
	@NonCPS
	def entries(m) {
	m.collect { k, v -> [k, v] }
	}

	/**
	* Opposite of build-in parallel, run map of steps in serial
	*
	* @param steps Map of String<name>: CPSClosure2<step> (or list of closures)
	*/
	def serial(steps) {
	stepsArray = entries(steps)
	for (i = 0; i < stepsArray.size; i++) {
	def step = stepsArray[i]
	def dummySteps = [:]
	def stepKey
	if (step[1] instanceof List \|\| step[1] instanceof Map) {
	for (j = 0; j < step[1].size(); j++) {
	if (step[1] instanceof List) {
	stepKey = j
	} else if (step[1] instanceof Map) {
	stepKey = step[1].keySet()[j]
	}
	dummySteps.put("step-${step[0]}-${stepKey}", step[1][stepKey])
	}
	} else {
	dummySteps.put(step[0], step[1])
	}
	parallel dummySteps
	}
	}

	/**
	* Partition given list to list of small lists
	* @param inputList input list
	* @param partitionSize (partition size, optional, default 5)
	*/
	def partitionList(inputList, partitionSize = 5) {
	List<List<String>> partitions = new ArrayList<>();
	for (int i = 0; i < inputList.size(); i += partitionSize) {
	partitions.add(new ArrayList<String>(inputList.subList(i, Math.min(i + partitionSize, inputList.size()))));
	}
	return partitions
	}

	/**
	* Get password credentials from store
	*
	* @param id Credentials name
	*/
	def getPasswordCredentials(id) {
	return getCredentialsById(id, 'password')
	}

	/**
	* Get SSH credentials from store
	*
	* @param id Credentials name
	*/
	def getSshCredentials(id) {
	return getCredentialsById(id, 'sshKey')
	}

	/**
	* Tests Jenkins instance for existence of plugin with given name
	* @param pluginName plugin short name to test
	* @return boolean result
	*/
	@NonCPS
	def jenkinsHasPlugin(pluginName) {
	return Jenkins.instance.pluginManager.plugins.collect { p -> p.shortName }.contains(pluginName)
	}

	@NonCPS
	def _needNotification(notificatedTypes, buildStatus, jobName) {
	if (notificatedTypes && notificatedTypes.contains("onchange")) {
	if (jobName) {
	def job = Jenkins.instance.getItem(jobName)
	def numbuilds = job.builds.size()
	if (numbuilds > 0) {
	//actual build is first for some reasons, so last finished build is second
	def lastBuild = job.builds[1]
	if (lastBuild) {
	if (lastBuild.result.toString().toLowerCase().equals(buildStatus)) {
	println("Build status didn't changed since last build, not sending notifications")
	return false;
	}
	}
	}
	}
	} else if (!notificatedTypes.contains(buildStatus)) {
	return false;
	}
	return true;
	}

	/**
	* Send notification to all enabled notifications services
	* @param buildStatus message type (success, warning, error), null means SUCCESSFUL
	* @param msgText message text
	* @param enabledNotifications list of enabled notification types, types: slack, hipchat, email, default empty
	* @param notificatedTypes types of notifications will be sent, default onchange - notificate if current build result not equal last result;
	* otherwise use - ["success","unstable","failed"]
	* @param jobName optional job name param, if empty env.JOB_NAME will be used
	* @param buildNumber build number param, if empty env.BUILD_NUM will be used
	* @param buildUrl build url param, if empty env.BUILD_URL will be used
	* @param mailFrom mail FROM param, if empty "jenkins" will be used, it's mandatory for sending email notifications
	* @param mailTo mail TO param, it's mandatory for sending email notifications, this option enable mail notification
	*/
	def sendNotification(buildStatus, msgText = "", enabledNotifications = [], notificatedTypes = ["onchange"], jobName = null, buildNumber = null, buildUrl = null, mailFrom = "jenkins", mailTo = null) {
	// Default values
	def colorName = 'blue'
	def colorCode = '#0000FF'
	def buildStatusParam = buildStatus != null && buildStatus != "" ? buildStatus : "SUCCESS"
	def jobNameParam = jobName != null && jobName != "" ? jobName : env.JOB_NAME
	def buildNumberParam = buildNumber != null && buildNumber != "" ? buildNumber : env.BUILD_NUMBER
	def buildUrlParam = buildUrl != null && buildUrl != "" ? buildUrl : env.BUILD_URL
	def subject = "${buildStatusParam}: Job '${jobNameParam} [${buildNumberParam}]'"
	def summary = "${subject} (${buildUrlParam})"

	if (msgText != null && msgText != "") {
	summary += "\n${msgText}"
	}
	if (buildStatusParam.toLowerCase().equals("success")) {
	colorCode = "#00FF00"
	colorName = "green"
	} else if (buildStatusParam.toLowerCase().equals("unstable")) {
	colorCode = "#FFFF00"
	colorName = "yellow"
	} else if (buildStatusParam.toLowerCase().equals("failure")) {
	colorCode = "#FF0000"
	colorName = "red"
	}
	if (_needNotification(notificatedTypes, buildStatusParam.toLowerCase(), jobNameParam)) {
	if (enabledNotifications.contains("slack") && jenkinsHasPlugin("slack")) {
	try {
	slackSend color: colorCode, message: summary
	} catch (Exception e) {
	println("Calling slack plugin failed")
	e.printStackTrace()
	}
	}
	if (enabledNotifications.contains("hipchat") && jenkinsHasPlugin("hipchat")) {
	try {
	hipchatSend color: colorName.toUpperCase(), message: summary
	} catch (Exception e) {
	println("Calling hipchat plugin failed")
	e.printStackTrace()
	}
	}
	if (enabledNotifications.contains("email") && mailTo != null && mailTo != "" && mailFrom != null && mailFrom != "") {
	try {
	mail body: summary, from: mailFrom, subject: subject, to: mailTo
	} catch (Exception e) {
	println("Sending mail plugin failed")
	e.printStackTrace()
	}
	}
	}
	}

	/**
	* Execute linux command and catch nth element
	* @param cmd command to execute
	* @param index index to retrieve
	* @return index-th element
	*/

	def cutOrDie(cmd, index) {
	def common = new com.mirantis.mk.Common()
	def output
	try {
	output = sh(script: cmd, returnStdout: true)
	def result = output.tokenize(" ")[index]
	return result;
	} catch (Exception e) {
	common.errorMsg("Failed to execute cmd: ${cmd}\n output: ${output}")
	}
	}

	/**
	* Check variable contains keyword
	* @param variable keywork is searched (contains) here
	* @param keyword string to look for
	* @return True if variable contains keyword (case insensitive), False if do not contains or any of input isn't a string
	*/

	def checkContains(variable, keyword) {
	if (env.getEnvironment().containsKey(variable)) {
	return env[variable] && env[variable].toLowerCase().contains(keyword.toLowerCase())
	} else {
	return false
	}
	}

	/**
	* Parse JSON string to hashmap
	* @param jsonString input JSON string
	* @return created hashmap
	*/
	def parseJSON(jsonString) {
	def m = [:]
	def lazyMap = new JsonSlurperClassic().parseText(jsonString)
	m.putAll(lazyMap)
	return m
	}

	/**
	* Test pipeline input parameter existence and validity (not null and not empty string)
	* @param paramName input parameter name (usually uppercase)
	*/
	def validInputParam(paramName) {
	return env.getEnvironment().containsKey(paramName) && env[paramName] != null && env[paramName] != ""
	}

	/**
	* Take list of hashmaps and count number of hashmaps with parameter equals eq
	* @param lm list of hashmaps
	* @param param define parameter of hashmap to read and compare
	* @param eq desired value of hashmap parameter
	* @return count of hashmaps meeting defined condition
	*/

	@NonCPS
	def countHashMapEquals(lm, param, eq) {
	return lm.stream().filter { i -> i[param].equals(eq) }.collect(java.util.stream.Collectors.counting())
	}

	/**
	* Execute shell command and return stdout, stderr and status
	*
	* @param cmd Command to execute
	* @return map with stdout, stderr, status keys
	*/

	def shCmdStatus(cmd) {
	def res = [:]
	def stderr = sh(script: 'mktemp', returnStdout: true).trim()
	def stdout = sh(script: 'mktemp', returnStdout: true).trim()

	try {
	def status = sh(script: "${cmd} 1>${stdout} 2>${stderr}", returnStatus: true)
	res['stderr'] = sh(script: "cat ${stderr}", returnStdout: true)
	res['stdout'] = sh(script: "cat ${stdout}", returnStdout: true)
	res['status'] = status
	} finally {
	sh(script: "rm ${stderr}", returnStdout: true)
	sh(script: "rm ${stdout}", returnStdout: true)
	}

	return res
	}

	/**
	* Retry commands passed to body
	*
	* @param times Number of retries
	* @param delay Delay between retries (in seconds)
	* @param body Commands to be in retry block
	* @return calling commands in body
	* @example retry ( 3 , 5 ) { function body }* retry{ function body }
	*/

	def retry(int times = 5, int delay = 0, Closure body) {
	int retries = 0
	def exceptions = []
	while (retries++ < times) {
	try {
	return body.call()
	} catch (e) {
	sleep(delay)
	}
	}
	currentBuild.result = "FAILURE"
	throw new Exception("Failed after $times retries")
	}

	/**
	* Wait for user input with timeout
	*
	* @param timeoutInSeconds Timeout
	* @param options Options for input widget
	*/
	def waitForInputThenPass(timeoutInSeconds, options = [message: 'Ready to go?']) {
	def userInput = true
	try {
	timeout(time: timeoutInSeconds, unit: 'SECONDS') {
	userInput = input options
	}
	} catch (err) { // timeout reached or input false
	def user = err.getCauses()[0].getUser()
	if ('SYSTEM' == user.toString()) { // SYSTEM means timeout.
	println("Timeout, proceeding")
	} else {
	userInput = false
	println("Aborted by: [${user}]")
	throw err
	}
	}
	return userInput
	}

	/**
	* Function receives Map variable as input and sorts it
	* by values ascending. Returns sorted Map
	* @param _map Map variable
	*/
	@NonCPS
	def SortMapByValueAsc(_map) {
	def sortedMap = _map.sort { it.value }
	return sortedMap
	}