Jenkins

def iniGetter(mymap, mylist, myhost){

  def objects = mylist
  def host = myhost
  def liste = []
  def default_list = []

  objects.each { obj ->
    if(mymap.containsKey(obj)){  
      liste = mymap.get(obj)
      if(! liste.contains(host)){
        liste.add(host)
        mymap.put(obj, liste)
      }
      liste = default_list

    }else{

      mymap.put(obj, [host])           
    }


  } //fin obj

} //fin func


def printMap(mymap, myname){
  def content = ""
  if(mymap.size() >= 1){


      content = content +"\n####### field: " + myname + "\n"

       mymap.keySet().each{
         content = content + "[" + it +"]" + "\n"

       def temp_list = mymap.get(it)
         if(! temp_list.isEmpty()){
           temp_list.each { elt ->
             content = content + elt + "\n"
           } //each temp_list

          }  // if empty
          content = content + "\n"
       } //each map

  } //if size

  return content

}


def printChild(myname, mylist){
  def content = ""
  content = content +"\n####### " + myname + " children\n"
  content = content + "[" + myname +":children]" + "\n"
  mylist.each { child ->
    content = content + child + "\n"
  }
  content = content + "\n"
  return content
}

def printWin(myli){

def cont= ""
def windows_os=["pegase", "pegase2012", "pegase2013","windows_server_2008", "windows_server_2016"] 
def var_ct = '''
[windows:vars]
ansible_connection=winrm
ansible_winrm_scheme=https
ansible_port=5986
ansible_winrm_server_cert_validation=ignore
validate_certs=false
ansible_winrm_transport=ntlm
ansible_winrm_operation_timeout_sec=60
ansible_winrm_read_timeout_sec=70
ansible_become=false
'''

def comp_l = windows_os.intersect(myli)

if(! comp_l.isEmpty()){
  cont=cont + printChild("windows", comp_l) + "\n" + var_ct

}

return cont

}


////////////Docker fonction

//equivalent du job dans jenkins
def DockerAnsible(InstallationStep, modules){
  ////modules = "compo1,compo2,compox"
  //cleanWs()
  def Basicat = getBasicat()
  def Platform = getPlatform()
  def HalfPlatform = getHalfPlatform()

  if (!TemplateType || TemplateType == null){ def TemplateType = "newversion" }

  //check parameters
  if(InstallationStep == null || modules == null){
     error('Please set all parameters before launching this job')
  }

   //content: pour stocker les extra vars
  def content= "Env: " + Platform + "\n"
  content = content + "PlaybookAction: " + InstallationStep + "\n"

  if(HalfPlatform == "all"){
      content = content + "half_platform: " + HalfPlatform+ "\n"
  }else{
      content = content + "half_platform: half_platform" + HalfPlatform+ "\n"
  }

  if(modules !="null"){
    def liste= modules.split(",")
    for(int i=0; i < liste.size(); i++){
        if(liste[i].trim() == "ora-api"){
            content = content + "oraapi_sources: 1"+ "\n"
        }else{
            content = content + liste[i].trim() + "_sources: 1"+ "\n"
        }
    }
  }else{
      error("Argument modules value is wrong!")
  }

  //
  def TemplateName
  if(TemplateType == "newversion"){
    TemplateName = NewTemplate(Basicat, Platform, InstallationStep)
  }else{ TemplateName = OldTemplate(Basicat, Platform, InstallationStep) }

  println("TemplateType: " + TemplateType)
  println("template name: " + TemplateName)
  println("extras variables: \n" + content)

  //call tower
  println("call tower")
  env['jobtemplate'] = TemplateName
    wrap([$class: 'AnsiColorBuildWrapper', colorMapName: "xterm"]) {

      ansibleTower(
      towerServer: 'AWX EIN PROD',
      jobTemplate: jobtemplate,
      importTowerLogs: true,
      removeColor: false,
      extraVars: content
      )

    }
}

def OldTemplate(basicat, platf, step){
  def TemplateName

  switch(step) {
    case 'install':
        TemplateName = basicat+"_"+platf+"_deployment"
        break;
    case 'clean':
        TemplateName = basicat+"_"+platf+"_clean"
        break;
    //rollback et validate
    default:
        TemplateName = basicat+"_"+platf+"_"+ step
        break;
  }
  return TemplateName
}

def NewTemplate(basicat, platf, step){
  def TemplateName

  switch(step) {
    case 'install':
        TemplateName = basicat+"_"+platf+"_deployment"
        break;
    //clean, rollback et validate
    default:
        TemplateName = basicat+"_"+platf+"_manage"
        break;
  }
  return TemplateName
}
//////////////////////////

def parsJson(json){
  def slurper = new groovy.json.JsonSlurper()
  return slurper.parseText(json)
}


def processStatusMail(String name, String status, String url, String duration){
 //create format for email templates
 def color = mapColorMail().get(status)
 return "<tr><td>${name}</td><td><font color=#${color}>${status}</font></td><td>${duration}</td><td>${url}</td></tr>"
}

def mapstar(){
  //Map for star of status job
  return ["AM":"star-silver","UAT":"star-silver","MNT":"star-orange","E1":"star-purple","E2":"star-orange","BENCH":"star-red-e","PEXP":"star-blue-e","PROD":"star-gold"]
}

def mapColorMail(){
  //Map for color of status job
  return ['SUCCESS': '7ED529', 'FAILURE': 'FF6666', 'UNSTABLE': 'FFD700', 'ABORTED': 'ACACAC']
}

def getBasicat() {
 //get app basicat
 job = JOB_NAME.split('_')
 return job.first().toLowerCase() 
}

def getPlatform() {
  //get app platform
 job = JOB_NAME.split('_')
 return job.last().toLowerCase().trim()
}

def getOriginBranch() {
 //get OriginBranch if existing
 if (params.OriginBranch.isEmpty() || !OriginBranch || OriginBranch == null || OriginBranch.contains("\${")) {  
  return false
 }else{
  return OriginBranch
 }
}

def getOriginOrRevision(){
 //get origin
 // origin is Revision or variable OriginBranch
 originBranch = getOriginBranch()
 if (!originBranch) {
  origin = getMapParameters().get('Revision')
  if(!origin){
   error("Sorry no variable commit Revision tag")
  }else{
   return origin
  }
 }else{
  return originBranch
 }
}

def getModulesVersions() {
 //get ModulesVersion  
 if (params.ModulesVersions.isEmpty() ||!ModulesVersions || ModulesVersions == null || ModulesVersions.contains("\${")) {
  modulesVersions = getMapParameters().get('ModulesVersions')
  if(!modulesVersions){
   error("Sorry no variable ModulesVersions")
  }else{
   return modulesVersions
  }
 }else{
  return ModulesVersions
 }
}

def getModulesInstall(ModulesVersions){
  //Give Map with modules version
  //Need the json with the ModulesVersions
  def modulesJson = parsJson(ModulesVersions)
  def map = [:]
  modulesJson.each{
    if(it.Install){
      map.put(it.Name,it.Version.toLowerCase())
    }
  }
  return map
}

//revoir cette fonction quand on l'appellera
def getModulesOtherActionInstall(ModulesVersions){
  def modulesJson = parsJson(ModulesVersions)
    def map = [:]
    modulesJson.each{ 
    if(it.Install){
      if(!(it.OtherAction.isEmpty())){
          otheractionList.add(it.OtherAction.get(0))
        }else{
            otheractionList.add("null")
        }
  }
   }
   return otheractionList
}

def getOnlyVersions(ModulesVersions){
 map = getModulesInstall(ModulesVersions)
 def moduleList = []
 map.each{ k, v ->
  moduleList.add(v)
 }
 return versionList
}

def getOnlyModules(ModulesVersions){
 map = getModulesInstall(ModulesVersions)
 def moduleList = []
 map.each{ k, v ->
  moduleList.add(k)
 }
 return moduleList
}

def getOtherAction(ModulesVersions){
    def modulesJson = parsJson(ModulesVersions)
    def otheractionList = []
    modulesJson.each{ 
    if(it.Install){
      if( it.OtherAction.size() > 0 ){
            otheractionList.add(it.OtherAction.get(0))
          }else{
            otheractionList.add("null")
          }
      }
   }
   return otheractionList
}

def getHalfPlatform() {
  //get HalfPlatform and check if is interger
 if (params.HalfPlatform.isEmpty()) {
  error("Sorry HalfPlatform was mandatory variable please set it")
 }else{
  if(HalfPlatform.toString().isInteger() || HalfPlatform == "all"){
    return HalfPlatform
  }else{
    error("The HalfPlatform wasn't a interger")
  }   
 }
}

def getHalfplatformString(){
  return "half_platform"
}

def getUrlGitEin(appli){
 //need basicat of application and return the git url
 return GITLAB_EIN_APPLI+'/'+appli+'.git'
}

def getMapParameters(){
 //get map of all parameter from artifact file
 //get JobName and JobNumber
 try { 
  step([$class: 'CopyArtifact',
  projectName: JobName,
  selector: [$class: 'SpecificBuildSelector', buildNumber: JobNumber]])
 }catch(none){
    error("Sorry we are not able to get the module version you want install. Either you have promote fail build or you have no module set.")
 }
 def propfile = readProperties file: 'parameters.properties'
 def map = [:]
 propfile.each{ k, v ->
    map.put(k,v)
 }
 return map
}

def createFileCallAWXEIN(credential){
  //create config file for call AWX API
  credentialUse = ""
  switch (credential) {
    case 'jenkins':
      credentialUse = "jenkins_awx_ein_prod_qNOJ1qXyxUxV9USr9JMv"
      break
    case 'awx':
      credentialUse = "jenkins_awx_ein_prod_awx"
      break
    default:
      error("Sorry the credential to use doesn't exist.")
      break
  }
  withCredentials([[$class: 'UsernamePasswordMultiBinding',
    credentialsId: credentialUse,
    usernameVariable: 'TowerLogin', passwordVariable: 'TowerPassword']]) {
      writeFile file: '.tower_cli.cfg', text: "host=https://${AWX_EIN}\nusername = "\
      +TowerLogin+"\npassword = "+TowerPassword
  }
  sh(script: '#!/bin/sh -e\nchmod 500 .tower_cli.cfg', returnStdout: false)
}

def cancelAWXJob(credential){
  //For set credential please see function createFileCallAWXEIN
  node('ansible'){
  deleteDir()
  createFileCallAWXEIN(credential)
  job = getBasicat()+"_"+getPlatform()+"_deployment"
  def json = sh(script: "#!/bin/sh -e\ntower-cli job list --status=running -f json", returnStdout: true).trim() 
  def idCancel = null
  parsJson(json).results.each{
    if(it.summary_fields.job_template.name == job){
      idCancel= it.id
    }
  }
  if(idCancel != null){
   sh(script: "#!/bin/sh -e\ntower-cli job cancel "+idCancel, returnStdout: true)
  }
 }
}

def checkPackageNexusEIN(tabl){
 //check if a package have this tag
 //warn when you call the nexus search fonction the group should be on the same order
 //than the tree on nexus ex: application, basicat, component, and version
 def urlSource = []
 group = "%2Fapplications"
 tabl.each{
   group = group+"%2F"+it
 }
 withCredentials([[$class: 'UsernamePasswordMultiBinding',
 credentialsId: 'api-nexus-credential-caf685bb7c',
 usernameVariable: 'userNexus', passwordVariable: 'pwdNexus']]) {
  json = sh(script: "#!/bin/sh -e\ncurl -u "+userNexus+":"+pwdNexus+" -k -X GET '"+EIN_NEXUS_SEARCH+EIN_REPO_HTTP+"&group="+group+"' 2>/dev/null", returnStdout: true).trim()
  def urljson = parsJson(json)
  //check if the package existing on nexus
  if(urljson.items.empty){
    println("⚠ Sorry, no package found on nexus. ⚠\nPackage: " + tabl)
    return null
  } else{
     urljson.items.each{
       if(!it.name.contains(PROMOTED_PACKAGE_NAME)){
        urlSource.add(it.assets.downloadUrl.first())
       }
      }
     if(urlSource.isEmpty()){
       println("⚠ Sorry, no package found on nexus. ⚠\nPackage: " + tabl)
       return null
     }else{
       return urlSource
     }
    }
  }
}

//get MR label
def getMR() {
  if(params.MR == null || params.MR.toString().contains('${')){
    return false
  }else{
    return params.MR.toLowerCase()
  }
}

//get campaign name
def getCampaign() {
  if(params.TestCampaign.isEmpty() || TestCampaign.toString().contains('${')){
    return false
  }else{
    return params.TestCampaign.toLowerCase()
  }
}

//get server
def getServer() {
 def platform = getPlatform()
 def halfPlatform = getHalfPlatform()
 job = platform + halfPlatform
 return job.toLowerCase() 
}

//get server
def getTestType() {
  if(params.Tests.isEmpty() || Tests.toString().contains('${')){
    return false
  }else{
    return params.Tests.toLowerCase()
  }
}

def getJobName(){
 //get variable JobName
 if (!JobName) {  
  return false
 }else{
  return JobName
 }
}

def getJobNumber(){
 //get variable JobNumber
 if (!JobNumber) {  
  return false
 }else{
  return JobNumber
 }
}

def getMailTag(){
  if (params.MailTag.isEmpty() || !MailTag || MailTag == null || MailTag.contains("\${")) {  
   return ""
  }else{
   return MailTag
  }
}

def getMailRecipient(){
  if (params.MailRecipient.isEmpty() || !MailRecipient || MailRecipient == null || MailRecipient.contains("\${")) {  
   return ""
  }else{
   return MailRecipient
  }
}

def deleteParameter(){
  //should be executed on master slave
  def jobName = JOB_NAME
  def job = Jenkins.instance.getItem(jobName)
  def parameter = job.getBuildByNumber(BUILD_ID.toInteger()).getAction(hudson.model.ParametersAction)
  job.getBuildByNumber(BUILD_ID.toInteger()).actions.remove(parameter)
}

def setVaultAWX(basicat,env,tag,pwd){
  try{
    json = ""
    json = sh(script: '#!/bin/sh -e\ntower-cli credential get -n '+basicat+'_'+env+'_vault -f json', returnStdout: true).trim()
    vaultid = parsJson(json).id
    input = '\'{"vault_password": "'+pwd+'", "vault_id": "'+tag+'"}\''
    json = sh(script: '#!/bin/sh -e\ntower-cli credential modify --inputs='+input+' '+vaultid+' 2>/dev/null', returnStdout: true).trim()
  }catch(Exception e1){
    error("Sorry vault credential doesn't exist on AWX")
  }
}

import groovy.json.*
import hudson.model.*
import java.util.*;


//recovery env var
def env = System.getenv();
def workspace = env['WORKSPACE'];
def basicat = env['Basicat'];
def awxuser = env['awxuser'];
def awxtoken = env['awxtoken'];
def slurper;
def awxurl="https://awxexampleom"

def inventory  = new File(workspace +"/" + basicat +"_inventory.yml" )
def temp_inventory  = new File(workspace +"/" + basicat +"_tempinventory.txt" )
def descap = " " + " "
def tescap = " " + " " + " " + " "
def jdata
def outfile
def cmdout

def getchildren(parent){
    def child;
    def childjson;
    def outputlist = []
    def slur
    child = "tower-cli group list -a --parent" + " " + parent + " -f json"
    childjson = child.execute().text;
    slur = new JsonSlurper().parseText(childjson)
    slur.results.each{
      //println "it: " +  it.name + "\n"
      outputlist.add(it.name)
    }
    return outputlist;
}


def gethost(compo_list){

    def hostchild;
    def hostchildjson
    def hostmap = [:]
    def hostslur
    for(int j=0; j < compo_list.size(); j++){

        hostchild = "tower-cli host list -a --group" + " " + compo_list.get(j) + " -f json"
        hostchildjson = hostchild.execute().text;
        hostslur = new JsonSlurper().parseText(hostchildjson)
        hostslur.results.each{
          //println "it: " +  it.name + "\n"
          hostmap.put(it.name,it.id)

        }
    }
      return hostmap;

}


def sub_system = ['platon7', 'platon6','pegase']
def platform_list = ['half_platform1', 'half_platform2', 'half_platform3']

def environments_all = getchildren("environments")
def components_list = getchildren(basicat)
def temp_middleware = getchildren("middlewares")
def operating_system = []
def middleware_list = []
def environments_list = []
def midfor_list
def hostname_list = []
def hostid_list = []

//operating_system = linux_system.plus(win_system)
sub_system.each {
  operating_system= operating_system.plus(getchildren(it))

}

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

  midfor_list = getchildren(temp_middleware.get(i))
  middleware_list = middleware_list.plus(midfor_list)
}

def hosts_map=gethost(components_list)
//println "hosts_map: " + hosts_map
hosts_map.each{ k, v ->
  if(hostname_list.contains("${k}") == false){ hostname_list.add("${k}") }
  if(hostid_list.contains("${v}") == false){ hostid_list.add("${v}") }

 }

println(" ")
/*
//println "\nenvironments_list: " + environments_list
println "\ncomponents_list: " + components_list
//println "\nlinux_system: " + linux_system
//println "win_system: " + win_system
println "\noperating_system: " + operating_system
println "\nmiddleware: " + middleware_list
println "\nplatform_list: " + platform_list
println "\nhostname_list: " + hostname_list
println "\nhostid_list: " + hostid_list
*/
println(" ")

  for(int y=0; y<hostid_list.size(); y++){  //gros for

    def hostdata_list = []
    def cmd = "curl -k -X GET --fail --silent --user" + " " + awxuser + ":" + awxtoken + " "
    cmd = cmd + awxurl +"/api/v2/hosts/" + hostid_list.get(y) + "/all_groups/?format=json" + " -o " + workspace +"/" + hostname_list.get(y) + ".json"
    cmdout = cmd.execute()
    cmdout.waitFor()

    outfile = new File(workspace +"/" + hostname_list.get(y) + ".json").text;
    jdata = new JsonSlurper().parseText(outfile)

    jdata.results.each{
      //println "it: " +  it.name
      hostdata_list.add(it.name)
    } //fin jdata result
    //println ("\n")

    environments_all.each { platf ->
      if (hostdata_list.contains(platf) == true) {
        if(environments_list.contains(platf) == false){ environments_list.add(platf)}

        temp_inventory.append("\n\n" + hostname_list.get(y) + ":")
        temp_inventory.append("\n" + descap + "env: " + platf)
        temp_inventory.append("\n" + descap + "platform:")

        platform_list.each { half -> 
         if (hostdata_list.contains(half) == true) { temp_inventory.append("\n" + tescap + "- " + half) }
        }
        temp_inventory.append("\n" + descap + "component:")
        components_list.each { compos -> 
         if (hostdata_list.contains(compos) ==true) { temp_inventory.append("\n" + tescap + "- " + compos) }
        }

        operating_system.each { opera -> 
         if (hostdata_list.contains(opera) == true) { temp_inventory.append("\n" + descap + "operating_system: " + opera) }
        }

        temp_inventory.append("\n" + descap + "middleware:")
        middleware_list.each { midd -> 
         if (hostdata_list.contains(midd)) { temp_inventory.append("\n" + tescap + "- " + midd) }
        }
        println ("")


      }//fin if platform

    }












} //gros for

//construction inventaire basicat_inventory.yml
inventory.append("---")
inventory.append("\nenvironments:")
environments_list.each{
  inventory.append("\n"+ descap + "- " + it)
}

inventory.append("\n\ncomponents:")
components_list.each{
  inventory.append("\n"+ tescap + "- " + it)
}

inventory.append("\n\nhosts:")
hostname_list.each{
  inventory.append("\n"+ tescap + "- " + it)
}

inventory.append(temp_inventory.text)

def call(Map pipelineParams) {
  pipeline {
    parameters {
        string(name: 'Basicat', description: 'Please enter here the basicat of your application')

    }
    agent { label 'master'}
    stages {

      stage('Creating branches'){               
        steps{
            script{
                cleanWs()
                basicat= Basicat.toLowerCase()
                def groupGit = "application"
                def createfrom = "g00r00c00"
                def inventorybranch = "master"  //branch where there are inventory.yml
                def urlGit = utility.getUrlGitEin(basicat)
                def repoid
                def repobranch
                def existing_branch = []
                def branch_list   //in inventory.yml
                def ymlcreate = " "

                //check if the repository exists
                withCredentials([
                    usernamePassword(credentialsId: 'gitlab-xxxf', usernameVariable: 'UserGitlab',
                                    passwordVariable: 'token')]) {
                    sh(script: '#!/bin/sh -e\n curl --header "PRIVATE-TOKEN: '\
                        +token+'" -X GET "https://'+GITLAB_EIN_FQDN+'/api/v4/projects?search='\
                        +basicat+'" > ifproject.yml 2>/dev/null')
                    }

                ymlfile = readYaml file: 'ifproject.yml'
                ymlfile.each{
                  if(it.path_with_namespace.toString()!=groupGit+'/'+basicat){
                        println it.path_with_namespace
                        error( "Repository " + groupGit+"/"+basicat + " doesn't exit ")
                  }
                  repoid = it.id
                  repobranch = it._links.repo_branches
                }


                //get env from branch master inventory.yml
                checkout ( [$class: 'GitSCM',branches: [[name: inventorybranch]],
                  userRemoteConfigs: [[credentialsId: 'gitlab-xxxf',url: urlGit]]])

                 ifinventory = fileExists 'inventory.yml'
                 if(ifinventory){
                   ymlinventory = readYaml file: 'inventory.yml'
                   branch_list = ymlinventory.environments
                   cleanWs()

                  }else{
                    cleanWs()
                    error("file inventory.yml not found on branch " + inventorybranch )
                  }


                 //Get existing branch
                withCredentials([
                  usernamePassword(credentialsId: 'gitlab-7xxxf', usernameVariable: 'UserGitlab',
                                  passwordVariable: 'token')]) {
                  sh(script: '#!/bin/sh -e\n curl --header "PRIVATE-TOKEN: '\
                      +token+'" -X GET  '+ repobranch+ ' > existingbranch.yml 2>/dev/null')
                }
                ymlbranch = readYaml file: 'existingbranch.yml'
                ymlbranch.each{
                  existing_branch.add(it.name)
                }
                println "Existing branches: " + existing_branch
                if( !existing_branch.contains(createfrom) ){error( "The branch " + createfrom + " doesn't exit.." )}


                //creating branches

                withCredentials([
                  usernamePassword(credentialsId: 'gitlab-7xxxxf', usernameVariable: 'UserGitlab',
                                  passwordVariable: 'token')]) {

                    println("\n Start creating environment branches\n Environments list: " + branch_list + "\n")
                    for(branch in branch_list){
                      if(!existing_branch.contains(branch)){
                          sh(script: '#!/bin/sh -e\n curl --header "PRIVATE-TOKEN: '\
                              +token+'" --request POST "https://'+GITLAB_EIN_FQDN+'/api/v4/projects/'\
                              +repoid+ '/repository/branches?branch=' + branch + '&ref=' + createfrom + '"> createbranch.yml 2>/dev/null')

                          ymlcreate = readYaml file: 'createbranch.yml'
                          if(ymlcreate.name != branch){ error("fail to create branch " + branch) }else{ println "Branch " + ymlcreate.name + " has been created"}                          

                      }else{ println 'branch ' + branch + ' already exists'}
                    }

                  } //withCre          
            } //fin script
        } //fin step
      } //fin stage('Creating branches')



    } //fin stages
  } //fin pipeline
} //fin call