1800617471

Committed 05 May 2025 11:53AM UTC coverage: 64.109% (-1.9%) from 65.983%

Build # 1800617471

Build Type

Pull #376

gitlab-ci

Committed by

lluiscampos

Commit Message

test: Remove unused `pr_merged` golden tests payload

The cherry-pick suggestion functionality cannot be verified with these
acceptance tests because they only run Git commands in dry mode. This is
presumably the reason why this test was never implemented...

Signed-off-by: Lluis Campos <lluis.campos@northern.tech>

Pull Request Pull Request #376: QA-1007: Replace source of truth for watch repos from release_tool to code

Run Details

54 of 85 new or added lines in 3 files covered. (63.53%)

46 existing lines in 3 files now uncovered.

1913 of 2984 relevant lines covered (64.11%)

2.13 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 / 1800617471

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