blob: 6259acd33c5938f192a04e0976bc98c2754b9a5a [file] [log] [blame]
Denis Egorenko8c606552016-12-07 14:22:50 +04001package com.mirantis.mcp
2
Artem Panchenkobc13d262017-01-20 12:40:58 +02003
Denis Egorenko8c606552016-12-07 14:22:50 +04004/**
Artem Panchenkobc13d262017-01-20 12:40:58 +02005 * Checkout Calico repository stage
Denis Egorenko8c606552016-12-07 14:22:50 +04006 *
Artem Panchenkobc13d262017-01-20 12:40:58 +02007 * @param config LinkedHashMap
8 * config includes next parameters:
9 * - project_name String, Calico project to clone
Artem Panchenkobc13d262017-01-20 12:40:58 +020010 * - host String, gerrit host
Artem Panchenko6fd07222017-02-13 17:13:23 +020011 * - projectNamespace String, gerrit namespace (optional)
12 * - commit String, Git commit to checkout (optional)
13 * - credentialsId String, gerrit credentials ID (optional)
14 * - refspec String, remote refs to be retrieved (optional)
Artem Panchenkobc13d262017-01-20 12:40:58 +020015 *
16 * Usage example:
17 *
18 * def calico = new com.mirantis.mcp.Calico()
19 * calico.checkoutCalico([
20 * project_name : 'cni-plugin',
21 * commit : 'mcp',
22 * host : 'gerrit.mcp.mirantis.net',
23 * ])
24 *
25 */
26def checkoutCalico(LinkedHashMap config) {
27
28 def git = new com.mirantis.mcp.Git()
29
30 def project_name = config.get('project_name')
31 def projectNamespace = config.get('projectNamespace', 'projectcalico')
Artem Panchenko6fd07222017-02-13 17:13:23 +020032 def commit = config.get('commit', '*')
Artem Panchenkobc13d262017-01-20 12:40:58 +020033 def host = config.get('host')
Artem Panchenkod10610b2017-01-27 18:09:52 +020034 def credentialsId = config.get('credentialsId', 'mcp-ci-gerrit')
Artem Panchenko6fd07222017-02-13 17:13:23 +020035 def refspec = config.get('refspec')
Artem Panchenkobc13d262017-01-20 12:40:58 +020036
37 if (!project_name) {
38 throw new RuntimeException("Parameter 'project_name' must be set for checkoutCalico() !")
39 }
Artem Panchenko6fd07222017-02-13 17:13:23 +020040 if (!host) {
41 throw new RuntimeException("Parameter 'host' must be set for checkoutCalico() !")
Artem Panchenkobc13d262017-01-20 12:40:58 +020042 }
43
44 stage ("Checkout ${project_name}"){
45 git.gitSSHCheckout([
46 credentialsId : credentialsId,
47 branch : commit,
48 host : host,
49 project : "${projectNamespace}/${project_name}",
50 withWipeOut : true,
Artem Panchenko6fd07222017-02-13 17:13:23 +020051 refspec : refspec,
Artem Panchenkobc13d262017-01-20 12:40:58 +020052 ])
53 }
54}
55
56
57/**
58 * Build bird binaries stage
59 *
60 * Usage example:
61 *
62 * def calico = new com.mirantis.mcp.Calico()
63 * calico.buildCalicoBird()
64 *
65 */
66def buildCalicoBird() {
67 stage ('Build bird binaries'){
68 sh "/bin/sh -x build.sh"
69 }
70}
71
72
73/**
74 * Publish bird binaries stage
75 *
76 * @param config LinkedHashMap
77 * config includes next parameters:
78 * - artifactoryServerName String, artifactory server name
79 * - binaryRepo String, repository (artifactory) for binary files
80 * - projectNamespace String, artifactory server namespace (optional)
81 * - publishInfo Boolean, whether publish a build-info object to Artifactory (optional)
82 *
83 * Usage example:
84 *
85 * def calico = new com.mirantis.mcp.Calico()
86 * calico.publishCalicoBird([
87 * artifactoryServerName : 'mcp-ci',
88 * binaryRepo : 'sandbox-binary-dev-local',
89 * ])
90 *
91 */
92def publishCalicoBird(LinkedHashMap config) {
93
94 def common = new com.mirantis.mcp.Common()
95 def git = new com.mirantis.mcp.Git()
96 def artifactory = new com.mirantis.mcp.MCPArtifactory()
97
98 def artifactoryServerName = config.get('artifactoryServerName')
99 def binaryRepo = config.get('binaryRepo')
100 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
101 def publishInfo = config.get('publishInfo', true)
102
103 if (!artifactoryServerName) {
104 throw new RuntimeException("Parameter 'artifactoryServerName' must be set for publishCalicoBird() !")
105 }
106 if (!binaryRepo) {
107 throw new RuntimeException("Parameter 'binaryRepo' must be set for publishCalicoBird() !")
108 }
109
110 def artifactoryServer = Artifactory.server(artifactoryServerName)
111 def buildInfo = Artifactory.newBuildInfo()
112
113 stage('Publishing bird artifacts') {
114 dir("artifacts"){
115 // define tag for bird
116 binaryTag = git.getGitDescribe(true) + "-" + common.getDatetime()
117 sh """
118 cp ../dist/bird bird-${binaryTag}
119 cp ../dist/bird6 bird6-${binaryTag}
120 cp ../dist/birdcl birdcl-${binaryTag}
121 """
122 writeFile file: "latest", text: "${binaryTag}"
123 // define mandatory properties for binary artifacts
124 // and some additional
125 def properties = artifactory.getBinaryBuildProperties([
126 "tag=${binaryTag}",
127 "project=bird"
128 ])
129
130 def uploadSpec = """{
131 "files": [
132 {
133 "pattern": "**",
134 "target": "${binaryRepo}/${projectNamespace}/bird/",
135 "props": "${properties}"
136 }
137 ]
138 }"""
139
140 // Upload to Artifactory.
141 artifactory.uploadBinariesToArtifactory(artifactoryServer, buildInfo, uploadSpec, publishInfo)
142 }// dir
143 }
144 return binaryTag
145}
146
147
148/**
149 * Test confd stage
150 *
151 *
152 * Usage example:
153 *
154 * def calico = new com.mirantis.mcp.Calico()
155 * calico.testCalicoConfd()
156 *
157 */
158def testCalicoConfd() {
159 stage ('Run unittest for confd'){
160 sh """
161 docker run --rm \
162 -v \$(pwd):/usr/src/confd \
163 -w /usr/src/confd \
164 golang:1.7 \
165 bash -c \
166 \"go get github.com/constabulary/gb/...; gb test -v\"
167 """
168 }
169}
170
171
172/**
173 * Build confd binaries stage
174 *
175 *
176 * Usage example:
177 *
178 * def calico = new com.mirantis.mcp.Calico()
179 * calico.buildCalicoConfd()
180 *
181 */
182def buildCalicoConfd() {
183 def container_src_dir = "/usr/src/confd"
184 def src_suffix = "src/github.com/kelseyhightower/confd"
185 def container_workdir = "${container_src_dir}/${src_suffix}"
186 def container_gopath = "${container_src_dir}/vendor:${container_src_dir}"
187
188 stage ('Build confd binary'){
189 sh """
190 docker run --rm \
191 -v \$(pwd):${container_src_dir} \
192 -w ${container_workdir} \
193 -e GOPATH=${container_gopath} \
194 golang:1.7 \
195 bash -c \
196 \"go build -a -installsuffix cgo -ldflags '-extld ld -extldflags -static' -a -x .\"
197 """
198 }
199}
200
201
202/**
203 * Publish confd binaries stage
204 *
205 * @param config LinkedHashMap
206 * config includes next parameters:
207 * - artifactoryServerName String, artifactory server name
208 * - binaryRepo String, repository (artifactory) for binary files
209 * - projectNamespace String, artifactory server namespace (optional)
210 * - publishInfo Boolean, whether publish a build-info object to Artifactory (optional)
211 *
212 * Usage example:
213 *
214 * def calico = new com.mirantis.mcp.Calico()
215 * calico.publishCalicoConfd([
216 * artifactoryServerName : 'mcp-ci',
217 * binaryRepo : 'sandbox-binary-dev-local',
218 * ])
219 *
220 */
221def publishCalicoConfd(LinkedHashMap config) {
222
223 def common = new com.mirantis.mcp.Common()
224 def git = new com.mirantis.mcp.Git()
225 def artifactory = new com.mirantis.mcp.MCPArtifactory()
226
227 def artifactoryServerName = config.get('artifactoryServerName')
228 def binaryRepo = config.get('binaryRepo')
229 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
230 def publishInfo = config.get('publishInfo', true)
231 def src_suffix = "src/github.com/kelseyhightower/confd"
232
233 if (!artifactoryServerName) {
234 throw new RuntimeException("Parameter 'artifactoryServerName' must be set for publishCalicoConfd() !")
235 }
236 if (!binaryRepo) {
237 throw new RuntimeException("Parameter 'binaryRepo' must be set for publishCalicoConfd() !")
238 }
239
240 def artifactoryServer = Artifactory.server(artifactoryServerName)
241 def buildInfo = Artifactory.newBuildInfo()
242
243 stage('Publishing confd artifacts') {
244
245 dir("artifacts"){
246 // define tag for confd
247 binaryTag = git.getGitDescribe(true) + "-" + common.getDatetime()
248 // create two files confd and confd+tag
249 sh "cp ../${src_suffix}/confd confd-${binaryTag}"
250 writeFile file: "latest", text: "${binaryTag}"
251
252 // define mandatory properties for binary artifacts
253 // and some additional
254 def properties = artifactory.getBinaryBuildProperties([
255 "tag=${binaryTag}",
256 "project=confd"
257 ])
258
259 def uploadSpec = """{
260 "files": [
261 {
262 "pattern": "**",
263 "target": "${binaryRepo}/${projectNamespace}/confd/",
264 "props": "${properties}"
265 }
266 ]
267 }"""
268
269 // Upload to Artifactory.
270 artifactory.uploadBinariesToArtifactory(artifactoryServer, buildInfo, uploadSpec, publishInfo)
271 }// dir
272 }
273 return binaryTag
274}
275
276
277/**
278 * Test libcalico stage
279 *
280 * Usage example:
281 *
282 * def calico = new com.mirantis.mcp.Calico()
283 * calico.testLibcalico()
284 *
285 */
286def testLibcalico() {
287 stage ('Run libcalico unittests'){
288 sh "make test"
289 }
290}
291
292
293/**
294 * Build calico/build image stage
295 *
296 * @param config LinkedHashMap
297 * config includes next parameters:
298 * - dockerRegistry String, Docker registry host to push image to (optional)
299 * - projectNamespace String, artifactory server namespace (optional)
300 * - buildImageTag String, calico/build image name (optional)
301 * - imageTag String, tag of docker image (optional)
302 *
303 * Usage example:
304 *
305 * def calicoFunc = new com.mirantis.mcp.Calico()
306 * calicoFunc.buildLibcalico([
307 * dockerRegistry : 'sandbox-docker-dev-virtual.docker.mirantis.net',
308 * ])
309 *
310 */
311def buildLibcalico(LinkedHashMap config) {
312
313 def common = new com.mirantis.mcp.Common()
314 def docker = new com.mirantis.mcp.Docker()
315 def git = new com.mirantis.mcp.Git()
316
317 def dockerRegistry = config.get('dockerRegistry')
318 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
319
320 def buildImage = config.get('buildImage', "calico/build")
321 def buildImageTag = config.get('buildImageTag', git.getGitDescribe(true) + "-" + common.getDatetime())
322
323 def buildContainerName = dockerRegistry ? "${dockerRegistry}/${projectNamespace}/${buildImage}:${buildImageTag}" : "${buildImage}:${buildImageTag}"
324
325 stage ('Build calico/build image') {
326 docker.setDockerfileLabels("./Dockerfile", ["docker.imgTag=${buildImageTag}"])
327 sh """
328 make calico/build BUILD_CONTAINER_NAME=${buildContainerName}
329 """
330 }
331 return [buildImage : buildImage,
332 buildImageTag : buildImageTag]
333}
334
335
336/**
337 * Switch Calico to use dowstream libcalico-go repository stage
338 *
339 * @param libCalicoGoCommit String, libcalico-go repository commit to checkout to
340 * @param host String, gerrit host
341 * @param glideLockFilePath String, relative path to glide.lock file
342 *
343 * Usage example:
344 *
345 * def calico = new com.mirantis.mcp.Calico()
346 * // Checkout calico code using calico.checkoutCalico() and then call this method from the same dir
347 * calico.switchCalicoToDownstreamLibcalicoGo('mcp', 'gerrit.mcp.mirantis.net', './glide.lock')
348 *
349 */
350def switchCalicoToDownstreamLibcalicoGo(String libCalicoGoCommit, String host, String glideLockFilePath) {
Sergey Reshetnyak70b1fe62017-01-31 22:27:06 +0300351 def common = new com.mirantis.mcp.Common()
Artem Panchenkobc13d262017-01-20 12:40:58 +0200352 def git = new com.mirantis.mcp.Git()
353
354 stage ('Switch to downstream libcalico-go') {
355 def libcalicogo_path = "${env.WORKSPACE}/tmp_libcalico-go"
356
357 git.gitSSHCheckout([
Artem Panchenkod10610b2017-01-27 18:09:52 +0200358 credentialsId : "mcp-ci-gerrit",
Artem Panchenkobc13d262017-01-20 12:40:58 +0200359 branch : libCalicoGoCommit,
360 host : host,
361 project : "projectcalico/libcalico-go",
362 targetDir : libcalicogo_path,
363 withWipeOut : true,
364 ])
365
Sergey Kulanovdef4df02017-02-01 14:17:46 +0200366 //FIXME(skulanov) we need to clean local cache for libcalico-go
367 sh "rm -rf ~/.glide/cache/src/file-*"
368
Artem Panchenkobc13d262017-01-20 12:40:58 +0200369 sh "cp ${glideLockFilePath} ${glideLockFilePath}.bak"
370 def glideLockFileContent = readFile file: glideLockFilePath
Sergey Reshetnyak70b1fe62017-01-31 22:27:06 +0300371 def glideMap = common.loadYAML(glideLockFileContent)
Artem Panchenkobc13d262017-01-20 12:40:58 +0200372
373 for (goImport in glideMap['imports']) {
374 if (goImport['name'].contains('libcalico-go')) {
375 goImport['repo'] = 'file:///go/src/github.com/projectcalico/libcalico-go'
376 goImport['vcs'] = 'git'
377 }
378 }
379
Sergey Reshetnyak70b1fe62017-01-31 22:27:06 +0300380 writeFile file: glideLockFilePath, text: common.dumpYAML(glideMap)
Artem Panchenkobc13d262017-01-20 12:40:58 +0200381
382 sh "LIBCALICOGO_PATH=${libcalicogo_path} make vendor"
Artem Panchenkod79430f2017-02-01 00:34:21 +0200383 // need this to reset glide.lock changes (vendor dir is already compiled)
384 // otherwise binaries will be versioned with '-dirty' suffix
385 sh "git checkout ."
Artem Panchenkobc13d262017-01-20 12:40:58 +0200386 }
387}
388
389
390/**
391 * Test Felix stage
392 *
393 * Usage example:
394 *
395 * def calico = new com.mirantis.mcp.Calico()
396 * calico.testFelix()
397 *
398 */
399def testFelix() {
400 stage ('Run felix unittests'){
401 // inject COMPARE_BRANCH variable for felix tests coverage (python code) check
402 def COMPARE_BRANCH = env.GERRIT_BRANCH ? "gerrit/${env.GERRIT_BRANCH}" : "origin/mcp"
403 sh "make ut UT_COMPARE_BRANCH=${COMPARE_BRANCH}"
404 }
405}
406
407
408/**
409 * Build calico/felix image stage
410 *
411 * @param config LinkedHashMap
412 * config includes next parameters:
413 * - dockerRegistry String, Docker registry host to push image to (optional)
414 * - projectNamespace String, artifactory server namespace (optional)
415 * - felixImage String, calico/felix image name (optional)
416 * - felixImageTag String, tag of docker image (optional)
Artem Panchenkocde3c232017-04-19 18:06:37 +0300417 * - dockerFilePath String, path to the Dockerfile for image (optional)
Artem Panchenkobc13d262017-01-20 12:40:58 +0200418 *
419 * Usage example:
420 *
421 * def calicoFunc = new com.mirantis.mcp.Calico()
422 * calicoFunc.buildFelix([
423 * dockerRegistry : 'sandbox-docker-dev-virtual.docker.mirantis.net',
424 * ])
425 *
426 */
427def buildFelix(LinkedHashMap config) {
428
429 def common = new com.mirantis.mcp.Common()
430 def docker = new com.mirantis.mcp.Docker()
431 def git = new com.mirantis.mcp.Git()
432
433 def dockerRegistry = config.get('dockerRegistry')
434 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
435
436 def felixImage = config.get('felixImage', "calico/felix")
437 def felixImageTag = config.get('felixImageTag', git.getGitDescribe(true) + "-" + common.getDatetime())
Artem Panchenkocde3c232017-04-19 18:06:37 +0300438 def dockerFilePath = config.get('dockerFilePath', "./docker-image/Dockerfile")
Artem Panchenkobc13d262017-01-20 12:40:58 +0200439
440 def felixContainerName = dockerRegistry ? "${dockerRegistry}/${projectNamespace}/${felixImage}:${felixImageTag}" : "${felixImage}:${felixImageTag}"
441
442 stage ('Build calico/felix image') {
Artem Panchenkocde3c232017-04-19 18:06:37 +0300443 docker.setDockerfileLabels(dockerFilePath, ["docker.imgTag=${felixImageTag}"])
Artem Panchenkobc13d262017-01-20 12:40:58 +0200444 sh """
445 make calico/felix
446 docker tag calico/felix ${felixContainerName}
447 """
448 }
449 return [felixImage : felixImage,
450 felixImageTag : felixImageTag]
451}
452
453/**
454 * Test Calicoctl stage
455 *
456 * Usage example:
457 *
458 * def calico = new com.mirantis.mcp.Calico()
459 * calico.testCalicoctl()
460 *
461 */
462def testCalicoctl() {
463 stage ('Run calicoctl unittests'){
464 sh "make test-containerized"
465 }
466}
467
468
469/**
Artem Panchenko6fd07222017-02-13 17:13:23 +0200470 * Run Calico system tests stage
471 *
472 * @param nodeImage String, docker image for calico/node container
473 * @param ctlImage String, docker image with calicoctl binary
474 * @param failOnErrors Boolean, raise exception if some tests fail (default true)
475 *
476 * Usage example:
477 *
478 * def calico = new com.mirantis.mcp.Calico()
479 * calico.systestCalico('calico/node:latest', 'calico/ctl:latest')
480 *
481 */
482def systestCalico(nodeImage, ctlImage, failOnErrors = true) {
483 stage ('Run Calico system tests'){
484 try {
485 // create fake targets to avoid execution of unneeded operations
486 sh """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300487 mkdir -p calicoctl_home/vendor
488 mkdir -p calico_home/vendor
Artem Panchenko6fd07222017-02-13 17:13:23 +0200489 """
490 // pull calico/ctl image and extract calicoctl binary from it
491 sh """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300492 cd calicoctl_home
Artem Panchenko6fd07222017-02-13 17:13:23 +0200493 mkdir -p dist
494 docker run --rm -u \$(id -u):\$(id -g) --entrypoint /bin/cp -v \$(pwd)/dist:/dist ${ctlImage} /calicoctl /dist/calicoctl
495 touch dist/calicoctl dist/calicoctl-linux-amd64
496 """
497 // pull calico/node image and extract required binaries
498 sh """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300499 cd calico_home
500 mkdir -p dist
Artem Panchenko6fd07222017-02-13 17:13:23 +0200501 mkdir -p calico_node/filesystem/bin
502 for calico_binary in startup allocate-ipip-addr calico-felix bird calico-bgp-daemon confd libnetwork-plugin; do
503 docker run --rm -u \$(id -u):\$(id -g) --entrypoint /bin/cp -v \$(pwd)/calico_node/filesystem/bin:/calicobin ${nodeImage} /bin/\${calico_binary} /calicobin/
504 done
505 cp calico_node/filesystem/bin/startup dist/
506 cp calico_node/filesystem/bin/allocate-ipip-addr dist/
507 touch calico_node/filesystem/bin/*
508 touch calico_node/.calico_node.created
509 """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300510 // execute systests against calico/node
511 sh """
512 cd calico_home
513 NODE_CONTAINER_NAME=${nodeImage} make st
514 """
Artem Panchenko6fd07222017-02-13 17:13:23 +0200515 } catch (Exception e) {
516 sh "make stop-etcd"
517 // FIXME: cleaning has to be done by make stop/clean targets
518 sh """
519 for dc in calico-felix cali-st-ext-nginx cali-st-host cali-st-gw host1 host2 host3; do
520 docker rm -f "\${dc}" || :
521 done
522 """
523 if (failOnErrors) {
524 throw e
525 }
526 }
527 }
528}
529
530
531/**
Artem Panchenkobc13d262017-01-20 12:40:58 +0200532 * Build Calico containers stages
533 *
534 * @param config LinkedHashMap
535 * config includes next parameters:
536 * - dockerRegistry String, repo with docker images
537 * - projectNamespace String, artifactory server namespace
538 * - artifactoryURL String, URL to repo with calico-binaries
Denis Egorenko8c606552016-12-07 14:22:50 +0400539 * - imageTag String, tag of images
540 * - nodeImage String, Calico Node image name
541 * - ctlImage String, Calico CTL image name
542 * - buildImage String, Calico Build image name
543 * - felixImage String, Calico Felix image name
544 * - confdBuildId String, Version of Calico Confd
545 * - confdUrl String, URL to Calico Confd
546 * - birdUrl, URL to Calico Bird
547 * - birdBuildId, Version of Calico Bird
548 * - bird6Url, URL to Calico Bird6
549 * - birdclUrl, URL to Calico BirdCL
550 *
551 * Usage example:
552 *
553 * def calicoFunc = new com.mirantis.mcp.Calico()
Artem Panchenkobc13d262017-01-20 12:40:58 +0200554 * calicoFunc.buildCalicoContainers([
555 * dockerRegistry : 'sandbox-docker-dev-virtual.docker.mirantis.net',
556 * artifactoryURL : 'https://artifactory.mcp.mirantis.net/artifactory/sandbox',
557 * ])
Denis Egorenko8c606552016-12-07 14:22:50 +0400558 *
559 */
Artem Panchenkobc13d262017-01-20 12:40:58 +0200560def buildCalicoContainers(LinkedHashMap config) {
Denis Egorenko8c606552016-12-07 14:22:50 +0400561
Artem Panchenkobc13d262017-01-20 12:40:58 +0200562 def common = new com.mirantis.mcp.Common()
563 def docker = new com.mirantis.mcp.Docker()
564 def git = new com.mirantis.mcp.Git()
Denis Egorenko8c606552016-12-07 14:22:50 +0400565
Artem Panchenkobc13d262017-01-20 12:40:58 +0200566 def dockerRegistry = config.get('dockerRegistry')
567 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
568 def artifactoryURL = config.get('artifactoryURL')
Denis Egorenko8c606552016-12-07 14:22:50 +0400569
Artem Panchenkobc13d262017-01-20 12:40:58 +0200570 if (! dockerRegistry ) {
571 error('dockerRegistry parameter has to be set.')
Denis Egorenko8c606552016-12-07 14:22:50 +0400572 }
573
Artem Panchenkobc13d262017-01-20 12:40:58 +0200574 if (! artifactoryURL ) {
575 error('artifactoryURL parameter has to be set.')
Denis Egorenko8c606552016-12-07 14:22:50 +0400576 }
577
Artem Panchenkobc13d262017-01-20 12:40:58 +0200578 def imgTag = config.get('imageTag', git.getGitDescribe(true) + "-" + common.getDatetime())
Denis Egorenko8c606552016-12-07 14:22:50 +0400579
Artem Panchenkobc13d262017-01-20 12:40:58 +0200580 def nodeImage = config.get('nodeImage', "calico/node")
581 def nodeRepo = "${dockerRegistry}/${projectNamespace}/${nodeImage}"
582 def nodeName = "${nodeRepo}:${imgTag}"
Denis Egorenko8c606552016-12-07 14:22:50 +0400583
Artem Panchenkobc13d262017-01-20 12:40:58 +0200584 def ctlImage = config.get('ctlImage', "calico/ctl")
585 def ctlRepo = "${dockerRegistry}/${projectNamespace}/${ctlImage}"
586 def ctlName = "${ctlRepo}:${imgTag}"
Denis Egorenko8c606552016-12-07 14:22:50 +0400587
588 // calico/build goes from libcalico
Artem Panchenkobc13d262017-01-20 12:40:58 +0200589 def buildImage = config.get('buildImage',"${dockerRegistry}/${projectNamespace}/calico/build:latest")
Denis Egorenko8c606552016-12-07 14:22:50 +0400590 // calico/felix goes from felix
Artem Panchenkobc13d262017-01-20 12:40:58 +0200591 def felixImage = config.get('felixImage', "${dockerRegistry}/${projectNamespace}/calico/felix:latest")
Denis Egorenko8c606552016-12-07 14:22:50 +0400592
Artem Panchenkobc13d262017-01-20 12:40:58 +0200593 def confdBuildId = config.get('confdBuildId', "${artifactoryURL}/${projectNamespace}/confd/latest".toURL().text.trim())
594 def confdUrl = config.get('confdUrl', "${artifactoryURL}/${projectNamespace}/confd/confd-${confdBuildId}")
Denis Egorenko8c606552016-12-07 14:22:50 +0400595
Artem Panchenkobc13d262017-01-20 12:40:58 +0200596 def birdBuildId = config.get('birdBuildId', "${artifactoryURL}/${projectNamespace}/bird/latest".toURL().text.trim())
597 def birdUrl = config.get('birdUrl', "${artifactoryURL}/${projectNamespace}/bird/bird-${birdBuildId}")
598 def bird6Url = config.get('bird6Url', "${artifactoryURL}/${projectNamespace}/bird/bird6-${birdBuildId}")
599 def birdclUrl = config.get('birdclUrl', "${artifactoryURL}/${projectNamespace}/bird/birdcl-${birdBuildId}")
Denis Egorenko8c606552016-12-07 14:22:50 +0400600
601 // add LABELs to dockerfiles
Pavel Petrov479f04f2017-08-04 23:38:38 +0300602 docker.setDockerfileLabels("./calicoctl_home/calicoctl/Dockerfile.calicoctl",
Denis Egorenko2bc89172016-12-21 17:31:19 +0400603 ["docker.imgTag=${imgTag}",
604 "calico.buildImage=${buildImage}",
605 "calico.birdclUrl=${birdclUrl}"])
Denis Egorenko8c606552016-12-07 14:22:50 +0400606
Pavel Petrov479f04f2017-08-04 23:38:38 +0300607 docker.setDockerfileLabels("./calico_home/calico_node/Dockerfile",
Denis Egorenko2bc89172016-12-21 17:31:19 +0400608 ["docker.imgTag=${imgTag}",
609 "calico.buildImage=${buildImage}",
610 "calico.felixImage=${felixImage}",
611 "calico.confdUrl=${confdUrl}",
612 "calico.birdUrl=${birdUrl}",
613 "calico.bird6Url=${bird6Url}",
614 "calico.birdclUrl=${birdclUrl}"])
Denis Egorenko8c606552016-12-07 14:22:50 +0400615
616 // Start build section
617 stage ('Build calico/ctl image'){
618 sh """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300619 cd calicoctl_home
Denis Egorenko8c606552016-12-07 14:22:50 +0400620 make calico/ctl \
621 CTL_CONTAINER_NAME=${ctlName} \
622 PYTHON_BUILD_CONTAINER_NAME=${buildImage} \
623 BIRDCL_URL=${birdclUrl}
624 """
625 }
626
627
628 stage('Build calico/node'){
629 sh """
Pavel Petrov479f04f2017-08-04 23:38:38 +0300630 cd calico_home
Denis Egorenko8c606552016-12-07 14:22:50 +0400631 make calico/node \
632 NODE_CONTAINER_NAME=${nodeName} \
633 PYTHON_BUILD_CONTAINER_NAME=${buildImage} \
634 FELIX_CONTAINER_NAME=${felixImage} \
635 CONFD_URL=${confdUrl} \
636 BIRD_URL=${birdUrl} \
637 BIRD6_URL=${bird6Url} \
638 BIRDCL_URL=${birdclUrl}
639 """
640 }
641
642
643 return [
Artem Panchenkobc13d262017-01-20 12:40:58 +0200644 CTL_CONTAINER_NAME:"${ctlImage}",
645 NODE_CONTAINER_NAME:"${nodeImage}",
646 CALICO_NODE_IMAGE_REPO:"${nodeRepo}",
647 CALICOCTL_IMAGE_REPO:"${ctlRepo}",
Denis Egorenko8c606552016-12-07 14:22:50 +0400648 CALICO_VERSION: "${imgTag}"
649 ]
650
651}
Artem Panchenkobc13d262017-01-20 12:40:58 +0200652
653
654/**
655 * Test Calico CNI plugin stage
656 *
657 * Usage example:
658 *
659 * def calico = new com.mirantis.mcp.Calico()
660 * calico.testCniPlugin()
661 *
662 */
663def testCniPlugin() {
664 stage ('Run cni-plugin unittests'){
665 // 'static-checks-containerized' target is removed from master
666 // and kept here only for backward compatibility
667 sh "make static-checks || make static-checks-containerized"
668 sh "make stop-etcd stop-kubernetes-master"
669 // 'stop-k8s-apiserver' target doesn't exist in Calico v2.0.0,
670 // so do not fail the stage if it's not found
671 sh "make stop-k8s-apiserver || true"
672 sh "make test-containerized"
673 }
674}
675
676
677/**
678 * Build calico/cni image stage
679 *
680 * @param config LinkedHashMap
681 * config includes next parameters:
682 * - dockerRegistry String, Docker registry host to push image to (optional)
683 * - projectNamespace String, artifactory server namespace (optional)
684 * - cniImage String, calico/cni image name (optional)
685 * - cniImageTag String, tag of docker image (optional)
686 *
687 * Usage example:
688 *
689 * def calicoFunc = new com.mirantis.mcp.Calico()
690 * calicoFunc.buildFelix([
691 * dockerRegistry : 'sandbox-docker-dev-virtual.docker.mirantis.net',
692 * ])
693 *
694 */
695def buildCniPlugin(LinkedHashMap config) {
696
697 def common = new com.mirantis.mcp.Common()
698 def docker = new com.mirantis.mcp.Docker()
699 def git = new com.mirantis.mcp.Git()
700
701 def dockerRegistry = config.get('dockerRegistry')
702 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
703
704 def cniImage = config.get('cniImage', "calico/cni")
705 def cniImageTag = config.get('cniImageTag', git.getGitDescribe(true) + "-" + common.getDatetime())
706
707 def cniContainerName = dockerRegistry ? "${dockerRegistry}/${projectNamespace}/${cniImage}:${cniImageTag}" : "${cniImage}:${cniImageTag}"
708
709 stage ('Build calico/cni image') {
710 docker.setDockerfileLabels("./Dockerfile", ["docker.imgTag=${cniImageTag}"])
711 sh """
712 make docker-image
713 docker tag calico/cni ${cniContainerName}
714 """
715 }
716 return [cniImage : cniImage,
717 cniImageTag : cniImageTag]
718}
719
720
721/**
722 * Publish calico docker image stage
723 *
724 * @param config LinkedHashMap
725 * config includes next parameters:
726 * - artifactoryServerName String, artifactory server name
727 * - dockerRegistry String, Docker registry host to push image to
Sergey Kulanova9e65042017-01-31 14:20:24 +0200728 * - dockerRepo String, repository (artifactory) for docker images, must not be Virtual
Artem Panchenkobc13d262017-01-20 12:40:58 +0200729 * - imageName String, Docker image name
730 * - imageTag String, Docker image tag
731 * - projectNamespace String, artifactory server namespace (optional)
732 * - publishInfo Boolean, whether publish a build-info object to Artifactory (optional)
733 *
734 * Usage example:
735 *
736 * def calico = new com.mirantis.mcp.Calico()
737 * calico.publishCalicoImage([
738 * artifactoryServerName : 'mcp-ci',
739 * dockerRegistry : 'sandbox-docker-dev-local.docker.mirantis.net'
740 * dockerRepo : 'sandbox-docker-dev-local',
741 * imageName : 'calico/node',
742 * imageTag : 'v.1.0.0',
743 * ])
744 *
745 */
Sergey Kulanova9e65042017-01-31 14:20:24 +0200746def publishCalicoImage(LinkedHashMap config) {
Artem Panchenkobc13d262017-01-20 12:40:58 +0200747 def artifactory = new com.mirantis.mcp.MCPArtifactory()
748
749 def artifactoryServerName = config.get('artifactoryServerName')
750 def dockerRegistry = config.get('dockerRegistry')
751 def dockerRepo = config.get('dockerRepo')
752 def imageName = config.get('imageName')
753 def imageTag = config.get('imageTag')
754 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
755 def publishInfo = config.get('publishInfo', true)
756
757 if (!artifactoryServerName) {
758 throw new RuntimeException("Parameter 'artifactoryServerName' must be set for publishCalicoImage() !")
759 }
760 if (!dockerRegistry) {
761 throw new RuntimeException("Parameter 'dockerRegistry' must be set for publishCalicoImage() !")
762 }
763 if (!dockerRepo) {
Sergey Kulanova9e65042017-01-31 14:20:24 +0200764 throw new RuntimeException("Parameter 'dockerRepo' must be set for publishCalicoImage() !")
Artem Panchenkobc13d262017-01-20 12:40:58 +0200765 }
766 if (!imageName) {
767 throw new RuntimeException("Parameter 'imageName' must be set for publishCalicoImage() !")
768 }
769 if (!imageTag) {
770 throw new RuntimeException("Parameter 'imageTag' must be set for publishCalicoImage() !")
771 }
772
773 def artifactoryServer = Artifactory.server(artifactoryServerName)
774 def buildInfo = publishInfo ? Artifactory.newBuildInfo() : null
775
776 stage("Publishing ${imageName}") {
777 artifactory.uploadImageToArtifactory(artifactoryServer,
778 dockerRegistry,
779 "${projectNamespace}/${imageName}",
780 imageTag,
781 dockerRepo,
782 buildInfo)
783 }
784 return "${dockerRegistry}/${projectNamespace}/${imageName}:${imageTag}"
785}
786
787
788/**
789 * Promote calico docker image stage
790 *
791 * @param config LinkedHashMap
792 * config includes next parameters:
793 * - imageProperties Map, docker image search properties in artifactory
794 * - artifactoryServerName String, artifactory server name
795 * - dockerLookupRepo String, docker repository (artifactory) to take image from
796 * - dockerPromoteRepo String, docker repository (artifactory) to promote image to
797 * - imageName String, Docker image name to promote with
798 * - imageTag String, Docker image tag to promote with
799 * - projectNamespace String, artifactory server namespace (optional)
800 * - defineLatest Boolean, promote with latest tag if true, default false (optional)
801 *
802 * Usage example:
803 *
804 * def calico = new com.mirantis.mcp.Calico()
805 * calico.promoteCalicoImage([
806 * imageProperties: [
807 * 'com.mirantis.targetImg': 'mirantis/projectcalico/calico/node',
808 * 'com.mirantis.targetTag': 'v1.0.0-2017010100000',
809 * ]
810 * artifactoryServerName : 'mcp-ci',
811 * dockerLookupRepo : 'sandbox-docker-dev-local',
812 * dockerPromoteRepo: 'sandbox-docker-prod-local',
813 * imageName: 'calico/node',
814 * imageTag: 'v1.0.0',
815 * defineLatest: true
816 * ])
817 *
818 */
819def promoteCalicoImage (LinkedHashMap config) {
820 def common = new com.mirantis.mcp.Common()
821 def git = new com.mirantis.mcp.Git()
822 def artifactory = new com.mirantis.mcp.MCPArtifactory()
823
824 def imageProperties = config.get('imageProperties')
825 def artifactoryServerName = config.get('artifactoryServerName')
826 def dockerLookupRepo = config.get('dockerLookupRepo')
827 def dockerPromoteRepo = config.get('dockerPromoteRepo')
828 def imageName = config.get('imageName')
829 def imageTag = config.get('imageTag')
830 def projectNamespace = config.get('projectNamespace', 'mirantis/projectcalico')
831 def defineLatest = config.get('defineLatest', false)
832
833if (!imageProperties) {
834 throw new RuntimeException("Parameter 'imageProperties' must be set for promoteCalicoImage() !")
835 }
836 if (!artifactoryServerName) {
837 throw new RuntimeException("Parameter 'artifactoryServerName' must be set for promoteCalicoImage() !")
838 }
839 if (!dockerLookupRepo) {
840 throw new RuntimeException("Parameter 'dockerLookupRepo' must be set for promoteCalicoImage() !")
841 }
842 if (!dockerPromoteRepo) {
843 throw new RuntimeException("Parameter 'dockerPromoteRepo' must be set for promoteCalicoImage() !")
844 }
845 if (!imageName) {
846 throw new RuntimeException("Parameter 'imageName' must be set for promoteCalicoImage() !")
847 }
848 if (!imageTag) {
849 throw new RuntimeException("Parameter 'imageTag' must be set for promoteCalicoImage() !")
850 }
851
852 def artifactoryServer = Artifactory.server(artifactoryServerName)
853 def artifactURI = artifactory.uriByProperties(artifactoryServer.getUrl(), imageProperties)
854
855 stage("Promote ${imageName}") {
856 if ( artifactURI ) {
857 def buildProperties = artifactory.getPropertiesForArtifact(artifactURI)
858 if (defineLatest) {
859 artifactory.promoteDockerArtifact(
860 artifactoryServer.getUrl(),
861 dockerLookupRepo,
862 dockerPromoteRepo,
863 "${projectNamespace}/${imageName}",
864 buildProperties.get('com.mirantis.targetTag').join(','),
865 'latest',
866 true
867 )
868 }
869 artifactory.promoteDockerArtifact(
870 artifactoryServer.getUrl(),
871 dockerLookupRepo,
872 dockerPromoteRepo,
873 "${projectNamespace}/${imageName}",
874 buildProperties.get('com.mirantis.targetTag').join(','),
875 "${imageTag}",
876 false
877 )
878 }
879 else {
880 throw new RuntimeException("Artifacts were not found, nothing to promote! "
881 +"Given image properties: ${imageProperties}")
882 }
883 }
884}
885
886
887def calicoFixOwnership() {
888 // files created inside container could be owned by root, fixing that
889 sh "sudo chown -R \$(id -u):\$(id -g) ${env.WORKSPACE} ${env.HOME}/.glide || true"
890}