1812297324

Committed 12 May 2025 06:44AM UTC coverage: 64.216% (-1.8%) from 65.983%

Build # 1812297324

Build Type

push

gitlab-ci

Committed by

web-flow

Commit Message

Merge pull request #376 from lluiscampos/QA-1007-limit-release-tool

QA-1007: Replace source of truth for watch repos from release_tool to code

Run Details

49 of 70 new or added lines in 3 files covered. (70.0%)

46 existing lines in 3 files now uncovered.

1904 of 2965 relevant lines covered (64.22%)

2.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.08

/menderqa_pipeline.go

package main

import (
        "bytes"
        "context"
        "strconv"
        "strings"
        "text/template"

        "github.com/google/go-github/v28/github"
        "github.com/sirupsen/logrus"
        gitlab "gitlab.com/gitlab-org/api/client-go"

        clientgitlab "github.com/mendersoftware/integration-test-runner/client/gitlab"
)

const clientPipelinePath = "Northern.tech/Mender/mender-qa"
const LatestStableYoctoBranch = "scarthgap"

func parseClientPullRequest(
        log *logrus.Entry,
        conf *config,
        action string,
        pr *github.PullRequestEvent,
) []buildOptions {
        log.Info("Pull request event with action: ", action)
        var builds []buildOptions

        // github pull request events to trigger a CI job for
        if action == "opened" || action == "edited" || action == "reopened" ||
                action == "synchronize" || action == "ready_for_review" {

                return getClientBuilds(log, conf, pr)
        }

        return builds
}

func getClientBuilds(log *logrus.Entry, conf *config, pr *github.PullRequestEvent) []buildOptions {

        var builds []buildOptions

        repo := pr.GetRepo().GetName()

        commitSHA := pr.PullRequest.Head.GetSHA()
        //GetLabel returns "mendersoftware:master", we just want the branch
        baseBranch := strings.Split(pr.PullRequest.Base.GetLabel(), ":")[1]

        makeQEMU := false

        // we need to have the latest integration/master branch in order to use the release_tool.py
        if err := updateIntegrationRepo(conf); err != nil {
                log.Warn(err.Error())
        }

        for _, watchRepo := range pipelineRepositories {
                // make sure the repo that the pull request is performed against is
                // one that we are watching.

                if watchRepo == repo {

                        // check if we need to build/test yocto
                        for _, qemuRepo := range clientPipelineRepositories {
                                if repo == qemuRepo {
                                        makeQEMU = true
                                }
                        }

                        switch repo {
                        case "meta-mender", "integration":
                                build := buildOptions{
                                        pr:         strconv.Itoa(pr.GetNumber()),
                                        repo:       repo,
                                        baseBranch: baseBranch,
                                        commitSHA:  commitSHA,
                                        makeQEMU:   makeQEMU,
                                }
                                builds = append(builds, build)

                        default:
                                var err error
                                var integrationsToTest []string

                                if integrationsToTest, err = getIntegrationVersionsUsingMicroservice(
                                        log,
                                        repo,
                                        baseBranch,
                                        conf,
                                ); err != nil {
                                        log.Errorf(
                                                "failed to get related microservices for repo: %s version: %s, failed "+
                                                        "with: %s\n",
                                                repo,
                                                baseBranch,
                                                err.Error(),
                                        )
                                        return nil
                                }
                                log.Infof(
                                        "the following integration branches: %s are using %s/%s",
                                        integrationsToTest,
                                        repo,
                                        baseBranch,
                                )

                                // one pull request can trigger multiple builds
                                for _, integrationBranch := range integrationsToTest {
                                        buildOpts := buildOptions{
                                                pr:         strconv.Itoa(pr.GetNumber()),
                                                repo:       repo,
                                                baseBranch: integrationBranch,
                                                commitSHA:  commitSHA,
                                                makeQEMU:   makeQEMU,
                                        }
                                        builds = append(builds, buildOpts)
                                }
                        }

                }
        }
        return builds
}

func isLegacyBuild(build *buildOptions, buildParameters []*gitlab.PipelineVariableOptions) bool {
        // We define a legacy build as either:
        // * A PR in integration repo with baseBranch 3.7.x
        // * A PR in any repo for which INTEGRATION_REV variable is set to 3.7.x
        if build.repo == "integration" {
                return build.baseBranch == "3.7.x"
        }
        for _, param := range buildParameters {
                if *param.Key == "INTEGRATION_REV" {
                        return *param.Value == "3.7.x"
                }
        }
        // This should never happen, INTEGRATION_REV must be found! But just in case...
        return false
}

func getMenderQARef(build *buildOptions, buildParameters []*gitlab.PipelineVariableOptions) string {
        if isLegacyBuild(build, buildParameters) {
                return "legacy-mender-3.7-lts"
        }
        return "master"
}

func triggerClientBuild(
        log *logrus.Entry,
        conf *config,
        build *buildOptions,
        pr *github.PullRequestEvent,
        buildOptions *BuildOptions,
) error {
        gitlabClient, err := clientgitlab.NewGitLabClient(
                conf.gitlabToken,
                conf.gitlabBaseURL,
                conf.dryRunMode,
        )
        if err != nil {
                return err
        }

        buildParameters, err := getClientBuildParameters(log, conf, build, buildOptions)
        if err != nil {
                return err
        }

        // first stop old pipelines with the same buildParameters
        stopStalePipelines(clientPipelinePath, log, gitlabClient, buildParameters)

        // trigger the new pipeline
        clientPipelinePath := "Northern.tech/Mender/mender-qa"
        ref := getMenderQARef(build, buildParameters)
        opt := &gitlab.CreatePipelineOptions{
                Ref:       &ref,
                Variables: &buildParameters,
        }

        variablesString := ""
        for _, variable := range *opt.Variables {
                variablesString += *variable.Key + ":" + *variable.Value + ", "
        }
        log.Infof(
                "Creating pipeline in project %s:%s with variables: %s",
                clientPipelinePath,
                *opt.Ref,
                variablesString,
        )

        pipeline, err := gitlabClient.CreatePipeline(clientPipelinePath, opt)
        if err != nil {
                log.Errorf("Could not create pipeline: %s", err.Error())
                return err
        }
        log.Infof("Created pipeline: %s", pipeline.WebURL)

        // Add the build variable matrix to the pipeline comment under a
        // drop-down tab
        // nolint:lll
        tmplString := `
Hello :smiley_cat: I created a pipeline for you here: [Pipeline-{{.Pipeline.ID}}]({{.Pipeline.WebURL}})

<details>
    <summary>Build Configuration Matrix</summary><p>

| Key   | Value |
| ----- | ----- |
{{range $i, $var := .BuildVars}}{{if $var.Value}}| {{$var.Key}} | {{$var.Value}} |{{printf "\n"}}{{end}}{{end}}

 </p></details>
`
        tmpl, err := template.New("Main").Parse(tmplString)
        if err != nil {
                log.Errorf(
                        "Failed to parse the build matrix template. Should never happen! Error: %s\n",
                        err.Error(),
                )
                return err
        }
        var buf bytes.Buffer
        if err = tmpl.Execute(&buf, struct {
                BuildVars []*gitlab.PipelineVariableOptions
                Pipeline  *gitlab.Pipeline
        }{
                BuildVars: filterOutEmptyVariables(*opt.Variables),
                Pipeline:  pipeline,
        }); err != nil {
                log.Errorf("Failed to execute the build matrix template. Error: %s\n", err.Error())
                return err
        }

        // Comment with a pipeline-link on the PR
        commentBody := buf.String()
        comment := github.IssueComment{
                Body: &commentBody,
        }

        err = githubClient.CreateComment(context.Background(),
                conf.githubOrganization, pr.GetRepo().GetName(), pr.GetNumber(), &comment)
        if err != nil {
                log.Infof("Failed to comment on the pr: %v, Error: %s", pr, err.Error())
        }

        return err
}

func getClientBuildParameters(
        log *logrus.Entry,
        conf *config,
        build *buildOptions,
        buildOptions *BuildOptions,
) ([]*gitlab.PipelineVariableOptions, error) {
        var err error
        readHead := "pull/" + build.pr + "/head"
        var buildParameters []*gitlab.PipelineVariableOptions

        var versionedRepositories []string
        if build.repo == "meta-mender" {
                // For meta-mender, pick master versions of all Mender release repos.
                versionedRepositories, err = getListOfVersionedRepositories("origin/master", conf)
        } else {
                versionedRepositories, err = getListOfVersionedRepositories(
                        "origin/"+build.baseBranch,
                        conf,
                )
        }
        if err != nil {
                log.Errorf("Could not get list of repositories: %s", err.Error())
                return nil, err
        }

        for _, versionedRepo := range versionedRepositories {
                // iterate over all the repositories (except the one we are testing) and
                // set the correct microservice versions

                // use the default "master" for both mender-qa, and meta-mender (set in CI)
                if versionedRepo != build.repo &&
                        versionedRepo != "integration" &&
                        build.repo != "meta-mender" {

                        repoKey := repoToBuildParameter(versionedRepo)

                        if _, exists := buildOptions.PullRequests[versionedRepo]; exists {
                                prVersion := buildOptions.PullRequests[versionedRepo]
                                buildParameters = append(
                                        buildParameters,
                                        &gitlab.PipelineVariableOptions{
                                                Key:   &repoKey,
                                                Value: &prVersion,
                                        },
                                )
                                continue
                        }
                        version, err := getServiceRevisionFromIntegration(
                                versionedRepo,
                                "origin/"+build.baseBranch,
                                conf,
                        )
                        if err != nil {
                                log.Errorf("failed to determine %s version: %s", versionedRepo, err.Error())
                                return nil, err
                        }
                        log.Infof("%s version %s is being used in %s", versionedRepo, version, build.baseBranch)
                        buildParameters = append(
                                buildParameters,
                                &gitlab.PipelineVariableOptions{
                                        Key:   &repoKey,
                                        Value: &version,
                                },
                        )
                }
        }

        // set the correct integration branches if we aren't performing a pull request against
        // integration
        if build.repo != "integration" && build.repo != "meta-mender" {
                integrationRevision := build.baseBranch
                if _, exists := buildOptions.PullRequests["integration"]; exists {
                        integrationRevision = buildOptions.PullRequests["integration"]
                }
                integrationRepoKey := repoToBuildParameter("integration")
                buildParameters = append(buildParameters,
                        &gitlab.PipelineVariableOptions{
                                Key:   &integrationRepoKey,
                                Value: &integrationRevision})

                if _, exists := buildOptions.PullRequests["meta-mender"]; exists {
                        metaMenderRevision := buildOptions.PullRequests["meta-mender"]
                        metaMenderRepoKey := repoToBuildParameter("meta-mender")
                        buildParameters = append(buildParameters,
                                &gitlab.PipelineVariableOptions{
                                        Key:   &metaMenderRepoKey,
                                        Value: &metaMenderRevision})
                }
        }

        // Set poky (& friends) and meta-mender revisions:
        // - If building a master PR, leave everything at defaults, which generally means
        //   meta-mender/master and poky/LatestStableYoctoBranch.
        // - If building meta-mender @ non-master, set poky branches to its baseBranch.
        // - If building any other repo @ non-master, set both meta-mender and poky to
        //   LatestStableYoctoBranch.
        if build.baseBranch != "master" {
                var pokyBranch string
                if build.repo == "meta-mender" {
                        pokyBranch = build.baseBranch
                } else {
                        pokyBranch = LatestStableYoctoBranch
                        metaMenderBranch := pokyBranch
                        metaMenderBranchKey := repoToBuildParameter("meta-mender")
                        buildParameters = append(
                                buildParameters,
                                &gitlab.PipelineVariableOptions{
                                        Key:   &metaMenderBranchKey,
                                        Value: &metaMenderBranch,
                                },
                        )
                }
                pokyBranchKey := repoToBuildParameter("poky")
                buildParameters = append(
                        buildParameters,
                        &gitlab.PipelineVariableOptions{Key: &pokyBranchKey, Value: &pokyBranch},
                )
                metaOEPokyBranchKey := repoToBuildParameter("meta-openembedded")
                buildParameters = append(
                        buildParameters,
                        &gitlab.PipelineVariableOptions{
                                Key:   &metaOEPokyBranchKey,
                                Value: &pokyBranch,
                        },
                )
                metaRPIPokyBranchKey := repoToBuildParameter("meta-raspberrypi")
                buildParameters = append(
                        buildParameters,
                        &gitlab.PipelineVariableOptions{
                                Key:   &metaRPIPokyBranchKey,
                                Value: &pokyBranch,
                        },
                )
        }

        // set the rest of the CI build parameters
        runIntegrationTests := "true"
        runIntegrationTestsKey := "RUN_INTEGRATION_TESTS"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &runIntegrationTestsKey, Value: &runIntegrationTests},
        )

        // Backend integration tests, from mender-qa pipeline, are only relevant for legacy builds
        if isLegacyBuild(build, buildParameters) {
                runBackendIntegrationTests := "true"
                if buildOptions.Fast {
                        runIntegrationTests = "false"
                }

                runBackendIntegrationTestsKey := "RUN_BACKEND_INTEGRATION_TESTS"
                buildParameters = append(
                        buildParameters,
                        &gitlab.PipelineVariableOptions{
                                Key: &runBackendIntegrationTestsKey, Value: &runBackendIntegrationTests,
                        },
                )
        }

        buildRepoKey := repoToBuildParameter(build.repo)
        buildParameters = append(buildParameters,
                &gitlab.PipelineVariableOptions{
                        Key:   &buildRepoKey,
                        Value: &readHead,
                })

        return getClientAcceptanceBuildParameters(buildParameters, build)
}

func getClientAcceptanceBuildParameters(
        buildParameters []*gitlab.PipelineVariableOptions,
        build *buildOptions,
) ([]*gitlab.PipelineVariableOptions, error) {
        var qemuParam string
        if build.makeQEMU {
                qemuParam = "true"
        } else {
                qemuParam = ""
        }

        buildX86UefiGrubKey := "BUILD_QEMUX86_64_UEFI_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildX86UefiGrubKey, Value: &qemuParam},
        )
        testX86UefiGrubKey := "TEST_QEMUX86_64_UEFI_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testX86UefiGrubKey, Value: &qemuParam},
        )

        buildX86BiosGrubKey := "BUILD_QEMUX86_64_BIOS_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildX86BiosGrubKey, Value: &qemuParam},
        )
        testX86BiosGrubKey := "TEST_QEMUX86_64_BIOS_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testX86BiosGrubKey, Value: &qemuParam},
        )

        buildX86BiosGrubGptKey := "BUILD_QEMUX86_64_BIOS_GRUB_GPT"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildX86BiosGrubGptKey, Value: &qemuParam},
        )
        testX86BiosGrubGptKey := "TEST_QEMUX86_64_BIOS_GRUB_GPT"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testX86BiosGrubGptKey, Value: &qemuParam},
        )

        buildVexpress := "BUILD_VEXPRESS_QEMU"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildVexpress, Value: &qemuParam},
        )
        testVexpress := "TEST_VEXPRESS_QEMU"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testVexpress, Value: &qemuParam},
        )

        buildVexpressFlash := "BUILD_VEXPRESS_QEMU_FLASH"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildVexpressFlash, Value: &qemuParam},
        )
        testVexpressFlash := "TEST_VEXPRESS_QEMU_FLASH"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testVexpressFlash, Value: &qemuParam},
        )

        buildVexpressUbootUefiGrub := "BUILD_VEXPRESS_QEMU_UBOOT_UEFI_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildVexpressUbootUefiGrub, Value: &qemuParam},
        )
        testVexpressUbootUefiGrub := "TEST_VEXPRESS_QEMU_UBOOT_UEFI_GRUB"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &testVexpressUbootUefiGrub, Value: &qemuParam},
        )

        buildBBBKey := "BUILD_BEAGLEBONEBLACK"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildBBBKey, Value: &qemuParam},
        )

        buildClientKey := "BUILD_CLIENT"
        buildClient := "true"
        buildParameters = append(
                buildParameters,
                &gitlab.PipelineVariableOptions{Key: &buildClientKey, Value: &buildClient},
        )

        return buildParameters, nil
}

// stopBuildsOfStaleClientPRs stops any running pipelines on a PR which has been merged.
func stopBuildsOfStaleClientPRs(
        log *logrus.Entry,
        pr *github.PullRequestEvent,
        conf *config) error {

        // If the action is "closed" the pull request was merged or just closed,
        // stop builds in both cases.
        if pr.GetAction() != "closed" {
                log.Debugf("stopBuildsOfStaleClientPRs: PR not closed, " +
                        "therefore not stopping it's pipeline")
                return nil
        }

        log.Debug("stopBuildsOfStaleClientPRs: Find any running pipelines and kill mercilessly!")

        for _, build := range getClientBuilds(log, conf, pr) {

                gitlabClient, err := clientgitlab.NewGitLabClient(
                        conf.gitlabToken,
                        conf.gitlabBaseURL,
                        conf.dryRunMode,
                )
                if err != nil {
                        return err
                }

                buildParams, err := getClientBuildParameters(log, conf, &build, NewBuildOptions())
                if err != nil {
                        log.Debug("stopBuildsOfStaleClientPRs: Failed to get the" +
                                "build-parameters for the build")
                        return err
                }

                stopStalePipelines(clientPipelinePath, log, gitlabClient, buildParams)
        }

        return nil

}

1	package main
2
3	import (
4	"bytes"
5	"context"
6	"strconv"
7	"strings"
8	"text/template"
9
10	"github.com/google/go-github/v28/github"
11	"github.com/sirupsen/logrus"
12	gitlab "gitlab.com/gitlab-org/api/client-go"
13
14	clientgitlab "github.com/mendersoftware/integration-test-runner/client/gitlab"
15	)
16
17	const clientPipelinePath = "Northern.tech/Mender/mender-qa"
18	const LatestStableYoctoBranch = "scarthgap"
19
20	func parseClientPullRequest(
21	log *logrus.Entry,
22	conf *config,
23	action string,
24	pr *github.PullRequestEvent,
25	) []buildOptions {	4✔
26	log.Info("Pull request event with action: ", action)	4✔
27	var builds []buildOptions	4✔
28		4✔
29	// github pull request events to trigger a CI job for	4✔
30	if action == "opened" \|\| action == "edited" \|\| action == "reopened" \|\|	4✔
31	action == "synchronize" \|\| action == "ready_for_review" {	7✔
32		3✔
33	return getClientBuilds(log, conf, pr)	3✔
34	}	3✔
35
36	return builds	2✔
37	}
38
39	func getClientBuilds(log logrus.Entry, conf config, pr *github.PullRequestEvent) []buildOptions {	3✔
40		3✔
41	var builds []buildOptions	3✔
42		3✔
43	repo := pr.GetRepo().GetName()	3✔
44		3✔
45	commitSHA := pr.PullRequest.Head.GetSHA()	3✔
46	//GetLabel returns "mendersoftware:master", we just want the branch	3✔
47	baseBranch := strings.Split(pr.PullRequest.Base.GetLabel(), ":")[1]	3✔
48		3✔
49	makeQEMU := false	3✔
50		3✔
51	// we need to have the latest integration/master branch in order to use the release_tool.py	3✔
52	if err := updateIntegrationRepo(conf); err != nil {	3✔
53	log.Warn(err.Error())	×
54	}	×
55
56	for _, watchRepo := range pipelineRepositories {	20✔
57	// make sure the repo that the pull request is performed against is	17✔
58	// one that we are watching.	17✔
59		17✔
60	if watchRepo == repo {	18✔
61		1✔
62	// check if we need to build/test yocto	1✔
63	for _, qemuRepo := range clientPipelineRepositories {	2✔
64	if repo == qemuRepo {	2✔
65	makeQEMU = true	1✔
66	}	1✔
67	}
68
69	switch repo {	1✔
70	case "meta-mender", "integration":	×
71	build := buildOptions{	×
72	pr: strconv.Itoa(pr.GetNumber()),	×
73	repo: repo,	×
74	baseBranch: baseBranch,	×
75	commitSHA: commitSHA,	×
76	makeQEMU: makeQEMU,	×
77	}	×
78	builds = append(builds, build)	×
79
80	default:	1✔
81	var err error	1✔
82	var integrationsToTest []string	1✔
83		1✔
84	if integrationsToTest, err = getIntegrationVersionsUsingMicroservice(	1✔
85	log,	1✔
86	repo,	1✔
87	baseBranch,	1✔
88	conf,	1✔
89	); err != nil {	1✔
90	log.Errorf(	×
91	"failed to get related microservices for repo: %s version: %s, failed "+	×
92	"with: %s\n",	×
93	repo,	×
94	baseBranch,	×
95	err.Error(),	×
96	)	×
97	return nil	×
98	}	×
99	log.Infof(	1✔
100	"the following integration branches: %s are using %s/%s",	1✔
101	integrationsToTest,	1✔
102	repo,	1✔
103	baseBranch,	1✔
104	)	1✔
105		1✔
106	// one pull request can trigger multiple builds	1✔
107	for _, integrationBranch := range integrationsToTest {	2✔
108	buildOpts := buildOptions{	1✔
109	pr: strconv.Itoa(pr.GetNumber()),	1✔
110	repo: repo,	1✔
111	baseBranch: integrationBranch,	1✔
112	commitSHA: commitSHA,	1✔
113	makeQEMU: makeQEMU,	1✔
114	}	1✔
115	builds = append(builds, buildOpts)	1✔
116	}	1✔
117	}
118
119	}
120	}
121	return builds	3✔
122	}
123
124	func isLegacyBuild(build buildOptions, buildParameters []gitlab.PipelineVariableOptions) bool {	1✔
125	// We define a legacy build as either:	1✔
126	// * A PR in integration repo with baseBranch 3.7.x	1✔
127	// * A PR in any repo for which INTEGRATION_REV variable is set to 3.7.x	1✔
128	if build.repo == "integration" {	1✔
129	return build.baseBranch == "3.7.x"	×
130	}	×
131	for _, param := range buildParameters {	2✔
132	if *param.Key == "INTEGRATION_REV" {	2✔
133	return *param.Value == "3.7.x"	1✔
134	}	1✔
135	}
136	// This should never happen, INTEGRATION_REV must be found! But just in case...
137	return false	×
138	}
139
140	func getMenderQARef(build buildOptions, buildParameters []gitlab.PipelineVariableOptions) string {	1✔
141	if isLegacyBuild(build, buildParameters) {	1✔
142	return "legacy-mender-3.7-lts"	×
143	}	×
144	return "master"	1✔
145	}
146
147	func triggerClientBuild(
148	log *logrus.Entry,
149	conf *config,
150	build *buildOptions,
151	pr *github.PullRequestEvent,
152	buildOptions *BuildOptions,
153	) error {	1✔
154	gitlabClient, err := clientgitlab.NewGitLabClient(	1✔
155	conf.gitlabToken,	1✔
156	conf.gitlabBaseURL,	1✔
157	conf.dryRunMode,	1✔
158	)	1✔
159	if err != nil {	1✔
160	return err	×
161	}	×
162
163	buildParameters, err := getClientBuildParameters(log, conf, build, buildOptions)	1✔
164	if err != nil {	1✔
165	return err	×
166	}	×
167
168	// first stop old pipelines with the same buildParameters
169	stopStalePipelines(clientPipelinePath, log, gitlabClient, buildParameters)	1✔
170		1✔
171	// trigger the new pipeline	1✔
172	clientPipelinePath := "Northern.tech/Mender/mender-qa"	1✔
173	ref := getMenderQARef(build, buildParameters)	1✔
174	opt := &gitlab.CreatePipelineOptions{	1✔
175	Ref: &ref,	1✔
176	Variables: &buildParameters,	1✔
177	}	1✔
178		1✔
179	variablesString := ""	1✔
180	for _, variable := range *opt.Variables {	2✔
181	variablesString += variable.Key + ":" + variable.Value + ", "	1✔
182	}	1✔
183	log.Infof(	1✔
184	"Creating pipeline in project %s:%s with variables: %s",	1✔
185	clientPipelinePath,	1✔
186	*opt.Ref,	1✔
187	variablesString,	1✔
188	)	1✔
189		1✔
190	pipeline, err := gitlabClient.CreatePipeline(clientPipelinePath, opt)	1✔
191	if err != nil {	1✔
192	log.Errorf("Could not create pipeline: %s", err.Error())	×
193	return err	×
194	}	×
195	log.Infof("Created pipeline: %s", pipeline.WebURL)	1✔
196		1✔
197	// Add the build variable matrix to the pipeline comment under a	1✔
198	// drop-down tab	1✔
199	// nolint:lll	1✔
200	tmplString := `	1✔
201	Hello :smiley_cat: I created a pipeline for you here: [Pipeline-{{.Pipeline.ID}}]({{.Pipeline.WebURL}})	1✔
202		1✔
203	<details>	1✔
204	<summary>Build Configuration Matrix</summary><p>	1✔
205		1✔
206	\| Key \| Value \|	1✔
207	\| ----- \| ----- \|	1✔
208	{{range $i, $var := .BuildVars}}{{if $var.Value}}\| {{$var.Key}} \| {{$var.Value}} \|{{printf "\n"}}{{end}}{{end}}	1✔
209		1✔
210	</p></details>	1✔
211	`	1✔
212	tmpl, err := template.New("Main").Parse(tmplString)	1✔
213	if err != nil {	1✔
214	log.Errorf(	×
215	"Failed to parse the build matrix template. Should never happen! Error: %s\n",	×
216	err.Error(),	×
217	)	×
218	return err	×
219	}	×
220	var buf bytes.Buffer	1✔
221	if err = tmpl.Execute(&buf, struct {	1✔
222	BuildVars []*gitlab.PipelineVariableOptions	1✔
223	Pipeline *gitlab.Pipeline	1✔
224	}{	1✔
225	BuildVars: filterOutEmptyVariables(*opt.Variables),	1✔
226	Pipeline: pipeline,	1✔
227	}); err != nil {	1✔
228	log.Errorf("Failed to execute the build matrix template. Error: %s\n", err.Error())	×
229	return err	×
230	}	×
231
232	// Comment with a pipeline-link on the PR
233	commentBody := buf.String()	1✔
234	comment := github.IssueComment{	1✔
235	Body: &commentBody,	1✔
236	}	1✔
237		1✔
238	err = githubClient.CreateComment(context.Background(),	1✔
239	conf.githubOrganization, pr.GetRepo().GetName(), pr.GetNumber(), &comment)	1✔
240	if err != nil {	1✔
241	log.Infof("Failed to comment on the pr: %v, Error: %s", pr, err.Error())	×
242	}	×
243
244	return err	1✔
245	}
246
247	func getClientBuildParameters(
248	log *logrus.Entry,
249	conf *config,
250	build *buildOptions,
251	buildOptions *BuildOptions,
252	) ([]*gitlab.PipelineVariableOptions, error) {	1✔
253	var err error	1✔
254	readHead := "pull/" + build.pr + "/head"	1✔
255	var buildParameters []*gitlab.PipelineVariableOptions	1✔
256		1✔
257	var versionedRepositories []string	1✔
258	if build.repo == "meta-mender" {	1✔
259	// For meta-mender, pick master versions of all Mender release repos.	×
260	versionedRepositories, err = getListOfVersionedRepositories("origin/master", conf)	×
261	} else {	1✔
262	versionedRepositories, err = getListOfVersionedRepositories(	1✔
263	"origin/"+build.baseBranch,	1✔
264	conf,	1✔
265	)	1✔
266	}	1✔
267	if err != nil {	1✔
268	log.Errorf("Could not get list of repositories: %s", err.Error())	×
269	return nil, err	×
270	}	×
271
272	for _, versionedRepo := range versionedRepositories {	2✔
273	// iterate over all the repositories (except the one we are testing) and	1✔
274	// set the correct microservice versions	1✔
275		1✔
276	// use the default "master" for both mender-qa, and meta-mender (set in CI)	1✔
277	if versionedRepo != build.repo &&	1✔
278	versionedRepo != "integration" &&	1✔
279	build.repo != "meta-mender" {	2✔
280		1✔
281	repoKey := repoToBuildParameter(versionedRepo)	1✔
282		1✔
283	if _, exists := buildOptions.PullRequests[versionedRepo]; exists {	2✔
284	prVersion := buildOptions.PullRequests[versionedRepo]	1✔
285	buildParameters = append(	1✔
286	buildParameters,	1✔
287	&gitlab.PipelineVariableOptions{	1✔
288	Key: &repoKey,	1✔
289	Value: &prVersion,	1✔
290	},	1✔
291	)	1✔
292	continue	1✔
293	}
294	version, err := getServiceRevisionFromIntegration(	1✔
295	versionedRepo,	1✔
296	"origin/"+build.baseBranch,	1✔
297	conf,	1✔
298	)	1✔
299	if err != nil {	1✔
300	log.Errorf("failed to determine %s version: %s", versionedRepo, err.Error())	×
301	return nil, err	×
302	}	×
303	log.Infof("%s version %s is being used in %s", versionedRepo, version, build.baseBranch)	1✔
304	buildParameters = append(	1✔
305	buildParameters,	1✔
306	&gitlab.PipelineVariableOptions{	1✔
307	Key: &repoKey,	1✔
308	Value: &version,	1✔
309	},	1✔
310	)	1✔
311	}
312	}
313
314	// set the correct integration branches if we aren't performing a pull request against
315	// integration
316	if build.repo != "integration" && build.repo != "meta-mender" {	2✔
317	integrationRevision := build.baseBranch	1✔
318	if _, exists := buildOptions.PullRequests["integration"]; exists {	2✔
319	integrationRevision = buildOptions.PullRequests["integration"]	1✔
320	}	1✔
321	integrationRepoKey := repoToBuildParameter("integration")	1✔
322	buildParameters = append(buildParameters,	1✔
323	&gitlab.PipelineVariableOptions{	1✔
324	Key: &integrationRepoKey,	1✔
325	Value: &integrationRevision})	1✔
326		1✔
327	if _, exists := buildOptions.PullRequests["meta-mender"]; exists {	2✔
328	metaMenderRevision := buildOptions.PullRequests["meta-mender"]	1✔
329	metaMenderRepoKey := repoToBuildParameter("meta-mender")	1✔
330	buildParameters = append(buildParameters,	1✔
331	&gitlab.PipelineVariableOptions{	1✔
332	Key: &metaMenderRepoKey,	1✔
333	Value: &metaMenderRevision})	1✔
334	}	1✔
335	}
336
337	// Set poky (& friends) and meta-mender revisions:
338	// - If building a master PR, leave everything at defaults, which generally means
339	// meta-mender/master and poky/LatestStableYoctoBranch.
340	// - If building meta-mender @ non-master, set poky branches to its baseBranch.
341	// - If building any other repo @ non-master, set both meta-mender and poky to
342	// LatestStableYoctoBranch.
343	if build.baseBranch != "master" {	2✔
344	var pokyBranch string	1✔
345	if build.repo == "meta-mender" {	1✔
346	pokyBranch = build.baseBranch	×
347	} else {	1✔
348	pokyBranch = LatestStableYoctoBranch	1✔
349	metaMenderBranch := pokyBranch	1✔
350	metaMenderBranchKey := repoToBuildParameter("meta-mender")	1✔
351	buildParameters = append(	1✔
352	buildParameters,	1✔
353	&gitlab.PipelineVariableOptions{	1✔
354	Key: &metaMenderBranchKey,	1✔
355	Value: &metaMenderBranch,	1✔
356	},	1✔
357	)	1✔
358	}	1✔
359	pokyBranchKey := repoToBuildParameter("poky")	1✔
360	buildParameters = append(	1✔
361	buildParameters,	1✔
362	&gitlab.PipelineVariableOptions{Key: &pokyBranchKey, Value: &pokyBranch},	1✔
363	)	1✔
364	metaOEPokyBranchKey := repoToBuildParameter("meta-openembedded")	1✔
365	buildParameters = append(	1✔
366	buildParameters,	1✔
367	&gitlab.PipelineVariableOptions{	1✔
368	Key: &metaOEPokyBranchKey,	1✔
369	Value: &pokyBranch,	1✔
370	},	1✔
371	)	1✔
372	metaRPIPokyBranchKey := repoToBuildParameter("meta-raspberrypi")	1✔
373	buildParameters = append(	1✔
374	buildParameters,	1✔
375	&gitlab.PipelineVariableOptions{	1✔
376	Key: &metaRPIPokyBranchKey,	1✔
377	Value: &pokyBranch,	1✔
378	},	1✔
379	)	1✔
380	}
381
382	// set the rest of the CI build parameters
383	runIntegrationTests := "true"	1✔
384	runIntegrationTestsKey := "RUN_INTEGRATION_TESTS"	1✔
385	buildParameters = append(	1✔
386	buildParameters,	1✔
387	&gitlab.PipelineVariableOptions{Key: &runIntegrationTestsKey, Value: &runIntegrationTests},	1✔
388	)	1✔
389		1✔
390	// Backend integration tests, from mender-qa pipeline, are only relevant for legacy builds	1✔
391	if isLegacyBuild(build, buildParameters) {	1✔
392	runBackendIntegrationTests := "true"	×
393	if buildOptions.Fast {	×
394	runIntegrationTests = "false"	×
395	}	×
396
397	runBackendIntegrationTestsKey := "RUN_BACKEND_INTEGRATION_TESTS"	×
398	buildParameters = append(	×
399	buildParameters,	×
400	&gitlab.PipelineVariableOptions{	×
401	Key: &runBackendIntegrationTestsKey, Value: &runBackendIntegrationTests,	×
402	},	×
403	)	×
404	}
405
406	buildRepoKey := repoToBuildParameter(build.repo)	1✔
407	buildParameters = append(buildParameters,	1✔
408	&gitlab.PipelineVariableOptions{	1✔
409	Key: &buildRepoKey,	1✔
410	Value: &readHead,	1✔
411	})	1✔
412		1✔
413	return getClientAcceptanceBuildParameters(buildParameters, build)	1✔
414	}
415
416	func getClientAcceptanceBuildParameters(
417	buildParameters []*gitlab.PipelineVariableOptions,
418	build *buildOptions,
419	) ([]*gitlab.PipelineVariableOptions, error) {	1✔
420	var qemuParam string	1✔
421	if build.makeQEMU {	2✔
422	qemuParam = "true"	1✔
423	} else {	1✔
UNCOV 424	qemuParam = ""	×
UNCOV 425	}	×
426
427	buildX86UefiGrubKey := "BUILD_QEMUX86_64_UEFI_GRUB"	1✔
428	buildParameters = append(	1✔
429	buildParameters,	1✔
430	&gitlab.PipelineVariableOptions{Key: &buildX86UefiGrubKey, Value: &qemuParam},	1✔
431	)	1✔
432	testX86UefiGrubKey := "TEST_QEMUX86_64_UEFI_GRUB"	1✔
433	buildParameters = append(	1✔
434	buildParameters,	1✔
435	&gitlab.PipelineVariableOptions{Key: &testX86UefiGrubKey, Value: &qemuParam},	1✔
436	)	1✔
437		1✔
438	buildX86BiosGrubKey := "BUILD_QEMUX86_64_BIOS_GRUB"	1✔
439	buildParameters = append(	1✔
440	buildParameters,	1✔
441	&gitlab.PipelineVariableOptions{Key: &buildX86BiosGrubKey, Value: &qemuParam},	1✔
442	)	1✔
443	testX86BiosGrubKey := "TEST_QEMUX86_64_BIOS_GRUB"	1✔
444	buildParameters = append(	1✔
445	buildParameters,	1✔
446	&gitlab.PipelineVariableOptions{Key: &testX86BiosGrubKey, Value: &qemuParam},	1✔
447	)	1✔
448		1✔
449	buildX86BiosGrubGptKey := "BUILD_QEMUX86_64_BIOS_GRUB_GPT"	1✔
450	buildParameters = append(	1✔
451	buildParameters,	1✔
452	&gitlab.PipelineVariableOptions{Key: &buildX86BiosGrubGptKey, Value: &qemuParam},	1✔
453	)	1✔
454	testX86BiosGrubGptKey := "TEST_QEMUX86_64_BIOS_GRUB_GPT"	1✔
455	buildParameters = append(	1✔
456	buildParameters,	1✔
457	&gitlab.PipelineVariableOptions{Key: &testX86BiosGrubGptKey, Value: &qemuParam},	1✔
458	)	1✔
459		1✔
460	buildVexpress := "BUILD_VEXPRESS_QEMU"	1✔
461	buildParameters = append(	1✔
462	buildParameters,	1✔
463	&gitlab.PipelineVariableOptions{Key: &buildVexpress, Value: &qemuParam},	1✔
464	)	1✔
465	testVexpress := "TEST_VEXPRESS_QEMU"	1✔
466	buildParameters = append(	1✔
467	buildParameters,	1✔
468	&gitlab.PipelineVariableOptions{Key: &testVexpress, Value: &qemuParam},	1✔
469	)	1✔
470		1✔
471	buildVexpressFlash := "BUILD_VEXPRESS_QEMU_FLASH"	1✔
472	buildParameters = append(	1✔
473	buildParameters,	1✔
474	&gitlab.PipelineVariableOptions{Key: &buildVexpressFlash, Value: &qemuParam},	1✔
475	)	1✔
476	testVexpressFlash := "TEST_VEXPRESS_QEMU_FLASH"	1✔
477	buildParameters = append(	1✔
478	buildParameters,	1✔
479	&gitlab.PipelineVariableOptions{Key: &testVexpressFlash, Value: &qemuParam},	1✔
480	)	1✔
481		1✔
482	buildVexpressUbootUefiGrub := "BUILD_VEXPRESS_QEMU_UBOOT_UEFI_GRUB"	1✔
483	buildParameters = append(	1✔
484	buildParameters,	1✔
485	&gitlab.PipelineVariableOptions{Key: &buildVexpressUbootUefiGrub, Value: &qemuParam},	1✔
486	)	1✔
487	testVexpressUbootUefiGrub := "TEST_VEXPRESS_QEMU_UBOOT_UEFI_GRUB"	1✔
488	buildParameters = append(	1✔
489	buildParameters,	1✔
490	&gitlab.PipelineVariableOptions{Key: &testVexpressUbootUefiGrub, Value: &qemuParam},	1✔
491	)	1✔
492		1✔
493	buildBBBKey := "BUILD_BEAGLEBONEBLACK"	1✔
494	buildParameters = append(	1✔
495	buildParameters,	1✔
496	&gitlab.PipelineVariableOptions{Key: &buildBBBKey, Value: &qemuParam},	1✔
497	)	1✔
498		1✔
499	buildClientKey := "BUILD_CLIENT"	1✔
500	buildClient := "true"	1✔
501	buildParameters = append(	1✔
502	buildParameters,	1✔
503	&gitlab.PipelineVariableOptions{Key: &buildClientKey, Value: &buildClient},	1✔
504	)	1✔
505		1✔
506	return buildParameters, nil	1✔
507	}
508
509	// stopBuildsOfStaleClientPRs stops any running pipelines on a PR which has been merged.
510	func stopBuildsOfStaleClientPRs(
511	log *logrus.Entry,
512	pr *github.PullRequestEvent,
513	conf *config) error {	2✔
514		2✔
515	// If the action is "closed" the pull request was merged or just closed,	2✔
516	// stop builds in both cases.	2✔
517	if pr.GetAction() != "closed" {	4✔
518	log.Debugf("stopBuildsOfStaleClientPRs: PR not closed, " +	2✔
519	"therefore not stopping it's pipeline")	2✔
520	return nil	2✔
521	}	2✔
522
523	log.Debug("stopBuildsOfStaleClientPRs: Find any running pipelines and kill mercilessly!")	1✔
524		1✔
525	for _, build := range getClientBuilds(log, conf, pr) {	2✔
526		1✔
527	gitlabClient, err := clientgitlab.NewGitLabClient(	1✔
528	conf.gitlabToken,	1✔
529	conf.gitlabBaseURL,	1✔
530	conf.dryRunMode,	1✔
531	)	1✔
532	if err != nil {	1✔
533	return err	×
534	}	×
535
536	buildParams, err := getClientBuildParameters(log, conf, &build, NewBuildOptions())	1✔
537	if err != nil {	1✔
538	log.Debug("stopBuildsOfStaleClientPRs: Failed to get the" +	×
539	"build-parameters for the build")	×
540	return err	×
541	}	×
542
543	stopStalePipelines(clientPipelinePath, log, gitlabClient, buildParams)	1✔
544	}
545
546	return nil	1✔
547
548	}

mendersoftware / integration-test-runner / 1812297324

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous