monorepo/Jenkinsfile at master · scheme-containers/monorepo · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
pipeline {
    agent {
        label 'docker-x86_64'
    }

    triggers {
        cron('@weekly')
    }

    options {
        disableConcurrentBuilds()
        buildDiscarder(logRotator(numToKeepStr: '10', artifactNumToKeepStr: '10'))
    }

    parameters {
        string(name: 'SCHEMES', defaultValue: 'biwascheme capyscheme chibi cyclone gauche guile lips meevax scheme-rs skint stak steel stklos tr7', description: 'Build and deploy theses Schemes')
        string(name: 'LINUXES', defaultValue: 'debian alpine', description: 'Build and deploy images on these linuxes')
        string(name: 'VERSIONS', defaultValue: 'head', description: 'Build and deploy these versions')
    }

    environment {
        DOCKER_HUB_USERNAME = credentials('DOCKER_HUB_USERNAME')
        DOCKER_HUB_TOKEN = credentials('DOCKER_HUB_TOKEN')
    }

    stages {

        stage('Build and deploy') {
            parallel {
                stage('x86_64') {
                    agent {
                        dockerfile {
                            label 'docker-x86_64'
                            filename 'Dockerfile.jenkins'
                            args '--user=root --privileged -v /var/run/docker.sock:/var/run/docker.sock'
                        }
                    }
                    steps {
                        script {
                            params.SCHEMES.split().each { SCHEME ->
                                params.LINUXES.split().each { LINUX ->
                                    params.VERSIONS.split().each { VERSION ->
                                        stage("${SCHEME} ${LINUX} ${VERSION} x86_64 build") {
                                            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                                sh "sleep 30"
                                                sh "make SCHEME=${SCHEME} VERSION=${VERSION} LINUX=${LINUX} ARCH=x86_64 DOCKER_ARGS=--no-cache build"
                                            }
                                        }

                                        stage("${SCHEME} ${LINUX} ${VERSION} x86_64 push") {
                                            timeout(time: 6, unit: 'HOURS') {
                                                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                                    sh 'docker login -u ${DOCKER_HUB_USERNAME} -p ${DOCKER_HUB_TOKEN}'
                                                    sh "make SCHEME=${SCHEME} VERSION=${VERSION} LINUX=${LINUX} ARCH=x86_64 push"
                                                    sh "docker logout"
                                                    sh "make SCHEME=${SCHEME} VERSION=${VERSION} LINUX=${LINUX} ARCH=x86_64 clean-image"
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                stage('arm') {
                    agent {
                        dockerfile {
                            label 'docker-arm'
                            filename 'Dockerfile.jenkins'
                            args '--user=root --privileged -v /var/run/docker.sock:/var/run/docker.sock'
                        }
                    }
                    steps {
                        script {
                            params.SCHEMES.split().each { SCHEME ->
                                params.LINUXES.split().each { LINUX ->
                                    params.VERSIONS.split().each { VERSION ->
                                        stage("${SCHEME} ${LINUX} ${VERSION} arm build") {
                                            timeout(time: 6, unit: 'HOURS') {
                                                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                                    sh "sleep 30"
                                                    sh "make SCHEME=${SCHEME} VERSION=${VERSION} LINUX=${LINUX} ARCH=aarch64 DOCKER_ARGS=--no-cache build"
                                                }
                                            }
                                        }

                                        stage("${SCHEME} ${LINUX} ${VERSION} arm push") {
                                            timeout(time: 6, unit: 'HOURS') {
                                                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                                                    sh 'docker login -u ${DOCKER_HUB_USERNAME} -p ${DOCKER_HUB_TOKEN}'
                                                    sh "make SCHEME=${SCHEME} VERSION=${VERSION} LINUX=${LINUX} ARCH=aarch64 push"
                                                    sh "docker logout"
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}