// Pipeline for the standalone debugger test build & test (test_* branches).

//

// This is the test-branch counterpart of Jenkinsfile-dev. It is generally identical, but:

// * checks out test_* branches instead of dev

// * does not set a GitHub commit status (test branches are ephemeral)

// * throttles/serializes builds and keeps fewer artifacts for a shorter time

// * cleans the workspace after each matrix cell to spare the shared test workers

//

// Three prebuilt deps are dropped into ./artifacts-extern where scripts/build.py finds them:

// * Qt (qt_<os>_*.zip, from Qt/qt-main-pipeline) -- commit-matched

// * LLDB (lldb_<os>_*.zip, from LLVM/llvm-main-pipeline) -- commit-matched

// * binaryninja dev (binaryninja_<os>_*.zip) -- lastSuccessful (latest dev)

//

// Qt and LLDB are commit-matched by reusing the copyExternalArtifactsEx shared library, the

// same one the binaryninja pipeline uses. binja feeds it commits from its llvm-build /

// qt-build submodules; the debugger has no such submodules, so it passes the commits

// explicitly (the qtCommit / llvmCommit params) read from scripts/target_llvm_version.py.

//

// Artifact filters come from the binaryninja repo: Qt/libclang filters from binja's

// Jenkinsfile-dev copyExternalArtifactsEx call, the lldb_<os>_<ver>.zip name from

// llvm-build/build.py, and the BN-dev path from a binaryninja-dev-pipeline artifact URL

// (artifacts/<os>/binaryninja_<os>_<ver>-dev_commercial.zip).

def jobFormatted = "`<${BUILD_URL}|${JOB_NAME} #${BUILD_NUMBER}>`"

slackResponse = null

void doCheckout() {

def maxRetries = 4

def retryDelays = [5, 30, 240] // Delays in seconds: 5s, 30s, 4m

def attempt = 0

while (attempt < maxRetries) {

try {

checkout scmGit(

branches: [[name: "${env.GIT_COMMIT}"]],

extensions: [

[$class: 'MessageExclusion', excludedMessage: '(?s).*skip-ci.*'],

cleanBeforeCheckout(),

cloneOption(noTags: true, reference: '', shallow: false),

submodule(depth: 1, parentCredentials: true, recursiveSubmodules: true, reference: '', shallow: true)

],

userRemoteConfigs: [[

credentialsId: '99e3b07a-7d66-49e6-8f18-9902340537f5',

url: 'git@github.com:Vector35/debugger.git',

name: 'origin',

refspec: '+refs/heads/test_*:refs/remotes/origin/test_*'

]]

)

return // Success

} catch (Exception e) {

attempt++

if (attempt >= maxRetries) {

echo "Checkout failed after ${maxRetries} attempts"

throw e

}

def retryDelay = retryDelays[attempt - 1]

echo "Checkout failed (attempt ${attempt}/${maxRetries}): ${e.message}"

echo "Retrying in ${retryDelay} seconds..."

sleep(retryDelay)

}

}

}

// Read a `name = "value"` assignment out of scripts/target_llvm_version.py.

String readTarget(String name) {

def text = readFile('scripts/target_llvm_version.py')

def matcher = (text =~ /(?m)^\s*${name}\s*=\s*["']([0-9a-fA-F]+)["']/)

return matcher ? matcher[0][1] : null

}

// copyArtifacts' lastSuccessful() can resolve to a build that Jenkins marked successful but

// that published no artifacts (a known Jenkins issue), which makes the copy fail. Walk back

// through successful builds and return a `specific()` selector for the most recent one that

// actually has an artifact matching `filter`.

def lastSuccessfulWithArtifacts(String projectName, String filter) {

def job = Jenkins.get().getItemByFullName(projectName)

for (def build = job.lastSuccessfulBuild; build != null; build = build.previousSuccessfulBuild) {

def artifacts = build.artifacts

if (artifacts != null && artifacts.any { org.apache.tools.ant.types.selectors.SelectorUtils.matchPath(filter, it.relativePath) }) {

return specific("${build.number}")

}

}

error "No successful build with artifacts matching '${filter}' found in ${projectName}"

}

// Pull the three prebuilt dependencies into ./artifacts-extern for scripts/build.py.

void copyExternalArtifacts(String os) {

// Qt + LLDB -- commit-matched via the shared library. The debugger has no llvm-build /

// qt-build submodules, so we pass the pinned commits explicitly (read from the text file)

// rather than letting copyExternalArtifactsEx derive them from submodule gitlinks.

// The library copies into artifacts-extern/<relativePath> (e.g. artifacts-extern/artifacts/

// qt_<os>_*.zip); build.py looks in both artifacts-extern/ and artifacts-extern/artifacts/.

copyExternalArtifactsEx(

qtJobName: "Qt/qt-main-pipeline",

qtArtifactFilter: "artifacts/qt_${os}_*.zip",

qtCommit: readTarget('qt_build_commit'),

llvmJobName: "LLVM/llvm-main-pipeline",

llvmArtifactFilter: "artifacts/lldb_${os}_*.zip",

llvmCommit: readTarget('llvm_build_commit'),

)

// Binary Ninja dev build -- the debugger builds against the latest dev, so this stays on

// lastSuccessful (not commit-matched). binja publishes one zip per edition under

// artifacts/<os>/, e.g. binaryninja_macosx_5.4.9891-dev_commercial.zip; the _commercial

// suffix selects exactly the commercial edition. build.py globs `binaryninja_*.zip` and

// takes the first hit, so this filter must resolve to a single zip -- it does.

// lastSuccessfulWithArtifacts (not lastSuccessful) skips "successful" binja builds that

// published no artifacts, which would otherwise make this copy fail.

def binjaFilter = "artifacts/${os}/binaryninja_${os}_*_commercial.zip"

copyArtifacts(

projectName: 'binaryninja-dev-pipeline',

selector: lastSuccessfulWithArtifacts('binaryninja-dev-pipeline', binjaFilter),

filter: binjaFilter,

flatten: true,

fingerprintArtifacts: true,

target: 'artifacts-extern'

)

}

void sendChangelog() {

def attachments = [

[

title: "Changelog",

text: getChangelog(),

fallback: ""

]

]

slackSend channel: slackResponse.threadId, attachments: attachments

}

void installMiseTools() {

lock(resource: "mise-install-${env.NODE_NAME}") {

if (isUnix()) {

sh script: 'mise trust mise.toml'

sh script: 'mise install --locked'

} else {

bat script: 'mise trust mise.toml'

bat script: 'mise install --locked'

}

}

}

void buildDebugger(String os) {

echo "Build debugger for ${os}"

if (isUnix()) {

sh script: 'mise run build'

} else {

bat script: 'mise run build'

}

}

pipeline {

agent {

label 'master'

}

parameters {

choice(name: 'OS_FILTER', choices: ['all', 'linux', 'linux-arm', 'macosx', 'win64'], description: 'Build for specific os')

}

options {

disableConcurrentBuilds() // Limit to 1 build per branch at a time

throttleJobProperty(

categories: ['Debugger Test Build'],

throttleEnabled: true,

throttleOption: 'category',

)

copyArtifactPermission("*")

// Only keep up to 3 artifacts per test branch for up to 30 days

buildDiscarder logRotator(artifactDaysToKeepStr: '30', artifactNumToKeepStr: '3', daysToKeepStr: '', numToKeepStr: '', removeLastBuild: true)

skipStagesAfterUnstable()

timeout(time: 120, unit: 'MINUTES')

}

environment {

PYTHONUNBUFFERED = '1'

}

stages {

stage('') {

when {

anyOf {

changelog '^((?!skip-ci).)*$'

expression { currentBuild.previousCompletedBuild == null }

triggeredBy cause: "UserIdCause"

}

}

stages {

stage('Start') {

steps {

script {

slackResponse = slackSend(message: "${jobFormatted} started")

}

slackSend channel: slackResponse.threadId, message: "Build started"

sendChangelog()

}

}

stage('BuildMatrix') {

matrix {

agent {

label "${os}"

}

when {

anyOf {

expression { params.OS_FILTER == 'all' }

expression { params.OS_FILTER == env.os }

}

}

axes {

axis {

name 'os'

values 'linux', 'linux-arm', 'macosx', 'win64'

}

}

options {

skipDefaultCheckout true

}

stages {

stage("Start") {

steps {

echo "Running on ${NODE_NAME}"

}

}

stage("Checkout") {

steps {

cleanWs()

doCheckout()

installMiseTools()

}

}

stage("Copy External Artifacts") {

steps {

lock("artifact-cache-${env.NODE_NAME}") {

copyExternalArtifacts(os)

}

}

}

stage("Build") {

steps {

buildDebugger(os)

}

}

}

post {

always {

archiveArtifacts artifacts: 'artifacts/**/*', fingerprint: true, allowEmptyArchive: true

processTestResults(slackResponse, 'commercial', os, 'test/results.xml')

}

failure {

slackSend channel: slackResponse.threadId, color: 'danger', message: "debugger-${os} Build Failed"

// Only remove very large external deps (Qt/LLDB/BN dev) on failure; keep build output for debugging

cleanWs notFailBuild: true, deleteDirs: true, patterns: [[pattern: 'artifacts-extern', type: 'INCLUDE']]

}

cleanup {

// Clean workspace after archiving/processing everything, except on failure

cleanWs notFailBuild: true, cleanWhenFailure: false

}

}

}

}

}

post {

success {

slackSend channel: slackResponse.threadId, message: "Build succeeded", color: "good"

slackSend channel: slackResponse.channelId, timestamp: slackResponse.ts, message: ":white_check_mark: ${jobFormatted} succeeded", color: "good"

}

unstable {

slackSend channel: slackResponse.threadId, message: "Build unstable", color: "warning"

slackSend channel: slackResponse.channelId, timestamp: slackResponse.ts, message: ":binja-shake: ${jobFormatted} unstable", color: "warning"

}

failure {

slackSend channel: slackResponse.threadId, message: "Build failed", color: "danger"

slackSend channel: slackResponse.channelId, timestamp: slackResponse.ts, message: ":x: ${jobFormatted} failed", color: "danger"

}

aborted {

slackSend channel: slackResponse.threadId, message: "Build aborted"

}

}

}

}

}