Jenkinsfile

import hudson.tasks.test.AbstractTestResultAction

def isWindows(){
  //If NODE_LABELS environment variable is null, we assume we are on master unix machine
  if (env.NODE_LABELS == null) {
    return false
  }
    return env.NODE_LABELS.toLowerCase().contains('windows')
}

// Answers if we are in a development branch (we assume is a development branch if it starts with "Pharo")
def isDevelopmentBranch() {
	def branchName =  env.BRANCH_NAME 
	def baseName = branchName.substring(0, 5)
	
	return baseName == "Pharo"
}

// Extracts Pharo version from the development branch (if it is "Pharo7.0" it will answer "7.0")
def getPharoVersionFromBranch() {
	def branchName =  env.BRANCH_NAME 
	return branchName.substring(5)
}

def shell(params){
    if(isWindows()) bat(params) 
    else sh(params)
}

def runTests(architecture, prefix=''){
  cleanWs()
  dir(env.STAGE_NAME) {
    try {
        unstash "bootstrap${architecture}"
        shell "bash -c 'bootstrap/scripts/run${prefix}Tests.sh ${architecture} ${env.STAGE_NAME}${prefix}'"
        junit allowEmptyResults: true, testResults: "${env.STAGE_NAME}${prefix}*.xml"
        archiveArtifacts allowEmptyArchive: true, artifacts: "${env.STAGE_NAME}${prefix}*.xml", fingerprint: true
        archiveArtifacts allowEmptyArchive: true, artifacts: "*.fuel", fingerprint: true
    } finally {
        // I am archiving the logs to check for crashes and errors.
        if(fileExists('PharoDebug.log')){
            shell "mv PharoDebug.log PharoDebug-${env.STAGE_NAME}${prefix}.log"
            archiveArtifacts allowEmptyArchive: true, artifacts: "PharoDebug-${env.STAGE_NAME}${prefix}.log", fingerprint: true
        }
        if(fileExists('crash.dmp')){
            shell "mv crash.dmp crash-${env.STAGE_NAME}${prefix}.dmp"
            archiveArtifacts allowEmptyArchive: true, artifacts: "crash-${env.STAGE_NAME}${prefix}.dmp", fingerprint: true
        }
        if(fileExists('progress.log')){
            shell "mv progress.log progress-${env.STAGE_NAME}${prefix}.log"
            shell "cat progress-${env.STAGE_NAME}${prefix}.log"
            archiveArtifacts allowEmptyArchive: true, artifacts: "progress-${env.STAGE_NAME}${prefix}.log", fingerprint: true
        }
    }
  }
}

def shellOutput(params){
  return (isWindows())? bat(returnStdout: true, script: params).trim() : sh(returnStdout: true, script: params).trim()
}

def notifyBuild(status){
  node('unix'){ stage('notify'){
  try{
  
  //If this is development, we send the email to the beta list
  def toMail = "log-ci-beta@lists.pharo.org"
  def buildKind = env.BRANCH_NAME
  if (env.CHANGE_ID != null){
    buildKind = "PR ${env.CHANGE_ID}"
  }
  if( isDevelopmentBranch() ) {
    toMail = "log-ci@lists.pharo.org"
    buildKind = getPharoVersionFromBranch()
  }
  
  //We checkout scm to have access to the log information
  checkout scm
  def owner = "pharo-project"
  def title = status
  
  //Get the merge information from the last commit
  def logMessage = shellOutput('git log -1 --format="%B"')
  def logSHA = shellOutput('git log -1 --format="%p"')
  
  def mailMessage = "Could not extract further issue information from commit message: ${logMessage}"
  
  //If there is no pull request information, we will send a log with the last commit message only
  def isPRMergeCommit = logMessage.startsWith("Merge pull request ")  
  if (isPRMergeCommit) {
    def pullRequestId = logMessage.split(' ')[3].substring(1)
    def githubPullRequestHttpRequest = "https://api.github.com/repos/${owner}/pharo/pulls/${pullRequestId}"
    def response = httpRequest githubPullRequestHttpRequest
    if (response.status == 200) { 
      def pullRequestJSON = readJSON text: response.content
      def pullRequestTitle = pullRequestJSON['title']
      
      def pullRequestUrl = "https://github.com/${owner}/pharo/pull/${pullRequestId}"
      mailMessage = """The Pull Request #${pullRequestId} was integrated: \"${pullRequestTitle}\"
Pull request url: ${pullRequestUrl}
"""
      title = pullRequestTitle
      def issueNumber = pullRequestJSON['head']['ref'].split('-')[0]
      def issueUrl = "https://github.com/pharo-project/pharo/issues/${issueNumber}"
      
      mailMessage += """
Issue Url: ${issueUrl}"""
    } else {
      mailMessage += """
No associated issue found"""
    }
  }
  
  def body = """There is a new Pharo build available!
  
The status of the build #${env.BUILD_NUMBER} was: ${status}.

${mailMessage}
Build Url: ${env.BUILD_URL}
"""

  mail to: toMail, cc: 'guillermopolito@gmail.com', subject: "[Pharo ${buildKind}] Build #${env.BUILD_NUMBER}: ${title}", body: body
  } catch (e) {
    //If there is an error during mail send, just print it and continue
    echo 'Error while sending email: ' + e.toString()
  } finally {
    cleanWs()
  }}}
}

def bootstrapImage(architectures){
   cleanWs()
  def builders = [:]
    
  for (arch in architectures) {
      // Need to bind the label variable before the closure - can't do 'for (label in labels)'
      def architecture = arch

      builders[architecture] = {
        dir(architecture) {

        try {
          stage ("Fetch Requirements-${architecture}") {  
            checkout scm
            // Stage 1 is to remove any artefacts, not required for Jenkins
            shell "BUILD_NUMBER=${BUILD_NUMBER} BOOTSTRAP_ARCH=${architecture} bash ./bootstrap/scripts/2-download.sh"
          }

          stage ("Bootstrap-${architecture}") {
            shell "BUILD_NUMBER=${BUILD_NUMBER} BOOTSTRAP_ARCH=${architecture} bash ./bootstrap/scripts/3-prepare.sh"
          }

          stage ("Full Image-${architecture}") {
            shell "BUILD_NUMBER=${BUILD_NUMBER} BOOTSTRAP_ARCH=${architecture} bash ./bootstrap/scripts/4-build.sh"
            stash includes: "bootstrap-cache/*.zip,bootstrap-cache/*.sources,bootstrap/scripts/**", name: "bootstrap${architecture}"
          }

          if( isDevelopmentBranch() ) {
            stage("Upload to files.pharo.org-${architecture}") {
              dir("bootstrap-cache") {
                  shell "BUILD_NUMBER=${env.BUILD_ID} bash ../bootstrap/scripts/prepare_for_upload.sh ${architecture}"
                sshagent (credentials: ['b5248b59-a193-4457-8459-e28e9eb29ed7']) {
                  shell "bash ../bootstrap/scripts/upload_to_files.pharo.org.sh"
                }
              }
            }
          }
      } finally {
          shell "ls -la"
          if(fileExists('PharoDebug.log')){
              shell "mv PharoDebug.log PharoDebug-bootstrap.log"
              archiveArtifacts allowEmptyArchive: true, artifacts: "PharoDebug-bootstrap.log", fingerprint: true
          }
          if(fileExists('crash.dmp')){
              shell "mv crash.dmp crash-bootstrap.dmp"
              archiveArtifacts allowEmptyArchive: true, artifacts: "crash-bootstrap.dmp", fingerprint: true
          }

        archiveArtifacts artifacts: 'bootstrap-cache/*.zip,bootstrap-cache/*.sources', fingerprint: true
        cleanWs()
      }
      }
    }
  }
  parallel builders 
}

def launchBenchmark(){
    node('unix'){ 
		stage('launchBenchmark'){
		  cleanWs()
	
			projectName = env.JOB_NAME
		  //We checkout scm to have access to the log information
		  checkout scm	
	
		  if (env.CHANGE_ID != null) {
				//If I am in a PR the head of the repository is a merge of the base commit (the development branch) and the PR commit.
				//I take the first parent of this commit. It is the commit in the PR 
				commit = shellOutput('git log HEAD^1 -1 --format="%H"')
				isPR = true
			} else {
				// If it is not a PR the commit to evaluate and put the status in github is the current commit
				commit = shellOutput('git log -1 --format="%H"')
				isPR = false
			}
	
			build job: 'pharo-benchmarks', parameters: [text(name: 'originProjectName', value: projectName), booleanParam(name: 'isPR', value: isPR), text(name: 'commit', value: commit)], wait: false
		}
	}
}

try{
  properties([disableConcurrentBuilds()])

  // We run the whole process in 64 bits all the time. 
  // The 32 bits process is only run when a PR is integrated

  def architectures

  if(isDevelopmentBranch()){
	  architectures = [/*'32',*/ '64']
  }else{
	  architectures = ['64']
  }

  node('unix') {
    timeout(60) {
      bootstrapImage(architectures)
    }
  }

  //Testing step
  def testers = [:]

  def platforms = ['unix', 'osx', 'windows']
  for (arch in architectures) {
    // Need to bind the label variable before the closure - can't do 'for (label in labels)'
    def architecture = arch
    for (platf in platforms) {
      // Need to bind the label variable before the closure - can't do 'for (label in labels)'
      def platform = platf
      // Disabling the test of 32bits
      if (arch != '32') {
        testers["${platform}-${architecture}"] = {
          node(platform) { 
            stage("Tests-${platform}-${architecture}") {
              timeout(35) {
                runTests(architecture)
                runTests(architecture, "Kernel")
              }
            }
          }
        }
      }
    }
  }
  parallel testers

  notifyBuild("SUCCESS")

  launchBenchmark()
} catch (e) {
  notifyBuild("FAILURE")
  throw e
}