func()

in pkg/gcp/gcb/gcb.go [300:424]
99 lines of code
22 McCabe index (conditional complexity)

func (g *GCB) SetGCBSubstitutions(toolOrg, toolRepo, toolRef string) (map[string]string, error) {
	gcbSubs := map[string]string{}

	gcbSubs["TOOL_ORG"] = toolOrg
	gcbSubs["TOOL_REPO"] = toolRepo
	gcbSubs["TOOL_REF"] = toolRef

	gcbSubs["K8S_ORG"] = release.GetK8sOrg()
	gcbSubs["K8S_REPO"] = release.GetK8sRepo()
	gcbSubs["K8S_REF"] = release.GetK8sRef()

	gcpUser := g.options.GcpUser
	if gcpUser == "" {
		var gcpUserErr error
		gcpUser, gcpUserErr = auth.GetCurrentGCPUser()
		if gcpUserErr != nil {
			return gcbSubs, gcpUserErr
		}
	} else {
		// TODO: Consider removing this once the 'gcloud auth' is testable in CI
		gcpUser = auth.NormalizeGCPUser(gcpUser)
	}

	gcbSubs["GCP_USER_TAG"] = gcpUser

	gcbSubs["TYPE"] = g.options.ReleaseType
	gcbSubs["TYPE_TAG"] = g.options.ReleaseType

	gcbSubs["RELEASE_BRANCH"] = g.options.Branch

	kc := kubecross.New()
	kcVersionBranch, err := kc.ForBranch(g.options.Branch)
	if err != nil {
		// If the kubecross version is not set, we will get a 404 from GitHub.
		// In that case, we do not err but use the latest version (unless we're on main branch)
		if g.options.Branch == git.DefaultBranch || !strings.Contains(err.Error(), "404") {
			return gcbSubs, errors.Wrap(err, "retrieve kube-cross version")
		}
		logrus.Infof("KubeCross version not set for %s, falling back to latest", g.options.Branch)
	}

	kcVersionLatest := kcVersionBranch
	if g.options.Branch != git.DefaultBranch {
		kcVersionLatest, err = kc.Latest()
		if err != nil {
			return gcbSubs, errors.Wrap(err, "retrieve latest kube-cross version")
		}

		// if kcVersionBranch is empty, the branch does not exist yet, we use
		// the latest kubecross version
		if kcVersionBranch == "" {
			kcVersionBranch = kcVersionLatest
		}
	}
	gcbSubs["KUBE_CROSS_VERSION"] = kcVersionBranch
	gcbSubs["KUBE_CROSS_VERSION_LATEST"] = kcVersionLatest

	// Stop here when doing a fast-forward
	if g.options.FastForward {
		return gcbSubs, nil
	}

	buildVersion := g.options.BuildVersion
	if g.options.Release && buildVersion == "" {
		return gcbSubs, errors.New("Build version must be specified when sending a release GCB run")
	}

	if g.options.Stage && g.options.BuildAtHead {
		hash, err := git.LSRemoteExec(git.GetDefaultKubernetesRepoURL(), "rev-parse", g.options.Branch)
		if err != nil {
			return gcbSubs, errors.Wrapf(
				err, "execute rev-parse for branch %s", g.options.Branch,
			)
		}

		fields := strings.Fields(hash)
		if len(fields) < 1 {
			return gcbSubs, errors.Errorf("unexpected output: %s", hash)
		}

		buildVersion = fields[0]
	}

	if buildVersion == "" {
		var versionErr error
		buildVersion, versionErr = g.versionClient.GetKubeVersionForBranch(
			release.VersionTypeCILatest, g.options.Branch,
		)
		if versionErr != nil {
			return gcbSubs, versionErr
		}
	}

	gcbSubs["BUILDVERSION"] = buildVersion

	buildVersionSemver, err := util.TagStringToSemver(buildVersion)
	if err != nil {
		return gcbSubs, errors.Wrap(err, "parse build version")
	}

	createBranch, err := g.releaseClient.NeedsCreation(
		g.options.Branch, g.options.ReleaseType, buildVersionSemver,
	)
	if err != nil {
		return nil, errors.Wrap(err, "check if branch needs to be created")
	}
	versions, err := g.releaseClient.GenerateReleaseVersion(
		g.options.ReleaseType, buildVersion,
		g.options.Branch, createBranch,
	)
	if err != nil {
		return nil, errors.Wrap(err, "generate release version")
	}
	primeSemver, err := util.TagStringToSemver(versions.Prime())
	if err != nil {
		return gcbSubs, errors.Wrap(err, "parse prime version")
	}

	gcbSubs["MAJOR_VERSION_TAG"] = strconv.FormatUint(primeSemver.Major, 10)
	gcbSubs["MINOR_VERSION_TAG"] = strconv.FormatUint(primeSemver.Minor, 10)
	gcbSubs["PATCH_VERSION_TAG"] = strconv.FormatUint(primeSemver.Patch, 10)
	gcbSubs["KUBERNETES_VERSION_TAG"] = primeSemver.String()

	return gcbSubs, nil
}