Skip to content

Latest commit

 

History

History
372 lines (299 loc) · 5.7 KB

Jenkins.md

File metadata and controls

372 lines (299 loc) · 5.7 KB
Raw

Jenkins

Artefakty

Archiwizuj

archiveArtifacts([
    allowEmptyArchive: true,
    artifacts: 'output/**',
    caseSensitive: true,
    defaultExcludes: true,
    fingerprint: false,
    onlyIfSuccessful: false
])

Kopiuj

copyArtifacts([
    projectName: "Builds/Something/Name",
    filter: 'target/*-somethin.jar',
    selector: lastSuccessful(),
    flatten: true
])

Credentiale

withCredentials([
    usernamePassword([
        credentialsId: 'CREDENTIAL_ID_USERA',
        usernameVariable: 'ADMIN_USERNAME',
        passwordVariable: 'ADMIN_PASSWORD'
    ]),
    string([
        credentialsId: 'CREDENTIAL_ID_API_KEY',
        variable: 'ADMIN_API_KEY'
    ]),
    sshUserPrivateKey([
        credentialsId: 'CREDENTIAL_ID_KLUCZ_SSH',
        keyFileVariable: 'ADMIN_SSH_KEY',
        passphraseVariable: '',
        usernameVariable: 'admin'
    ])
]) {
    // ...
}

Czekaj

sleep([
    unit: 'SECONDS',
    time: sleepTime
])

Czekaj aż coś zwróci true

waitUntil {
    // ...

    if (res.results != null) {
        return true
    } else {
        sleep([
            unit: 'SECONDS',
            time: 10
        ])

        return false
    }
}

Czyszczenie Workspacea

cleanWs()

Dynamiczne stage wykonywane równolegle

def stages = [:] // tak się tworzy tablicę asocjacyjną
def items = ['a', 'b', 'c']

items.each {
    stages[it] = { ->
        stage("Stage ${it}") {
            // ...
        }
    }
}

parallel stages

Docker

Buduj

docker.build(
    "nazwa:tag",
    "--build-arg ARGUMENT=wartosc ."
)

Buduj i wypchnij

def image = docker.build(
    "nazwa:tag",
    "--build-arg ARGUMENT=wartosc ."
)
image.push()

Użyj registry

docker.withRegistry('adres.registry.com', credentialeDoRegistry) {
    // ...
}

Git checkout

Prosty

git([
    url: '[email protected]:uzyszkodnik-lub-organizacja/i-repo.git',
    branch: 'master',
    credentialsId: TUTAJ_CREDENTIAL_ID,
    poll: true
])

Zaawansowany

checkout([
    scm: [
        $class: 'GitSCM',
        branches: [[ name: '*/master' ]],
        userRemoteConfigs: [
            [
                credentialsId: TUTAJ_CREDENTIAL_ID,
                url: '[email protected]:uzyszkodnik-lub-organizacja/i-repo.git'
            ]
        ]
    ]
])

Tylko jednego katalogu

checkout([
    scm: [
        $class: 'GitSCM',
        branches: [[ name: '*/master' ]],
        extensions: [
            [
                $class: 'SparseCheckoutPaths',
                sparseCheckoutPaths: [
                    [
                        path: 'katalog'
                    ]
                ]
            ]
        ],
        userRemoteConfigs: [
            [
                credentialsId: TUTAJ_CREDENTIAL_IT,
                url: '[email protected]:uzyszkodnik-lub-organizacja/i-repo.git'
            ]
        ]
    ]
])

sh('mv katalog/* .')

Razem z subrepo

checkout([
    $class: 'GitSCM',
    branches: [[name: env.BRANCH_NAME]],
    doGenerateSubmoduleConfigurations: false,
    extensions: [
        [
            $class: 'CloneOption',
            depth: 1,
            noTags: false,
            reference: '',
            shallow: true,
            timeout: 10
        ],
        [
            $class: 'SubmoduleOption',
            disableSubmodules: false,
            parentCredentials: true,
            recursiveSubmodules: true,
            reference: '',
            trackingSubmodules: false
        ]
    ],
    submoduleCfg: [],
    userRemoteConfigs: [
        [
            credentialsId: TUTAJ_CREDENTIAL_IT,
            url: '[email protected]:uzyszkodnik-lub-organizacja/i-repo.git'
        ]
    ]
])

Iteruj po tablicy

['a', 'b', 'c'].each {
    print(it)
}

Klauzula try-catch-finally

try {
    ...
} catch (err) {
    // err.message
} finally {

    stage('Clean up') {
        cleanWs()
    }

}

Koloruj output

ansiColor('xterm') {
    ...
}

Operacje na plikach

Czytaj plik tekstowy

String txt = readFile('./sciezka/do/pliku')

Zapisz plik tekstowy

writeFile([
    file: 'plik.txt', 
    text: "Hello World\nNew Line"
])

Pobierz zawartość adresu URL (za pomocą GET)

String resp = new URL("http://example.org").getText()

Pythonowy Virtualenv

withPythonEnv('/usr/bin/python3') {
    ...
}

Regexp

def matches = (subject =~ /^(grupa)$/)

if (matches) {
    String grupa = matches[0][1]

    // Clean matches - important! Otherwise Jenkins will want to serialize it!
    matches = null
}

Timeout

timeout([
    time: 5,
    activity: true,
    unit: 'MINUTES'
]) {
    sh('npm run test')
}

Triggeruj inny build

build([
    job: "/Path/To/Job/Without/'jobs'",
    parameters: [
        string(name: 'STRING_PARAM', value: 'dupa'),
        booleanParam(name: 'SOME_FLAG', value: true)
    ],
    propagate: false,
    wait: false
])

Status

Aborted

currentBuild.result = 'ABORTED'
error("Wolololo")

Unstable

unstable('Found Issues')

Wykonaj coś w konkretnym katalogu

String dirName = 'katalog'
sh("mkdir ${dirName}") // pamietaj żeby stworzyć katalog najpierw
dir(dirName) {
    // coś
}

Wykonaj coś ze zmienną środowiskową

withEnv(['ZMIENNA=wartosc']) {
    // coś
    print(env.ZMIENNA)
}

Wykonaj komendę i przypisz output do zmiennej

something = sh(
    script: "uname -a",
    returnStdout: true
)

Note: Użyj .trim() na końcu, aby pozbyć się białych znaków.