func()

in release/pkg/generate_spec.go [76:214]

• 117 lines of code
• 26 McCabe index (conditional complexity)

func (r *ReleaseConfig) GetVersionsBundles(imageDigests map[string]string) ([]anywherev1alpha1.VersionsBundle, error) {
	versionsBundles := []anywherev1alpha1.VersionsBundle{}

	certManagerBundle, err := r.GetCertManagerBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for cert-manager")
	}

	coreClusterApiBundle, err := r.GetCoreClusterAPIBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for core cluster-api")
	}

	kubeadmBootstrapBundle, err := r.GetKubeadmBootstrapBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for cluster-api kubeadm-bootstrap")
	}

	kubeadmControlPlaneBundle, err := r.GetKubeadmControlPlaneBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for cluster-api kubeadm-control-plane")
	}

	awsBundle, err := r.GetAwsBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for AWS infrastructure provider")
	}

	dockerBundle, err := r.GetDockerBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for Docker infrastructure provider")
	}

	eksaBundle, err := r.GetEksaBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for eks-a tools component")
	}

	ciliumBundle, err := r.GetCiliumBundle()
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for Cilium")
	}

	kindnetdBundle, err := r.GetKindnetdBundle()
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for Kindnetd")
	}

	fluxBundle, err := r.GetFluxBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for Flux controllers")
	}

	etcdadmBootstrapBundle, err := r.GetEtcdadmBootstrapBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for external Etcdadm bootstrap")
	}

	etcdadmControllerBundle, err := r.GetEtcdadmControllerBundle(imageDigests)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for external Etcdadm controller")
	}

	bottlerocketAdminBundle, err := r.GetBottlerocketAdminBundle()
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting bundle for Bottlerocket admin container")
	}

	var tinkerbellBundle anywherev1alpha1.TinkerbellBundle
	if r.DevRelease && r.BuildRepoBranchName == "main" {
		tinkerbellBundle, err = r.GetTinkerbellBundle(imageDigests)
		if err != nil {
			return nil, errors.Wrapf(err, "Error getting bundle for Tinkerbell infrastructure provider")
		}
	}

	eksDReleaseMap, err := readEksDReleases(r)
	if err != nil {
		return nil, err
	}

	bottlerocketSupportedK8sVersions, err := getBottlerocketSupportedK8sVersions(r)
	if err != nil {
		return nil, errors.Wrapf(err, "Error getting supported Kubernetes versions for bottlerocket")
	}

	for channel, release := range eksDReleaseMap {
		if channel == "latest" || !utils.SliceContains(bottlerocketSupportedK8sVersions, channel) {
			continue
		}
		releaseNumber := release.(map[interface{}]interface{})["number"]
		releaseNumberInt := releaseNumber.(int)
		releaseNumberStr := strconv.Itoa(releaseNumberInt)

		kubeVersion, err := getEksDKubeVersion(channel, releaseNumberStr)
		if err != nil {
			return nil, errors.Wrapf(err, "Error getting kubeversion for eks-d %s-%s release", channel, releaseNumberStr)
		}
		shortKubeVersion := kubeVersion[1:strings.LastIndex(kubeVersion, ".")]

		eksDReleaseBundle, err := r.GetEksDReleaseBundle(channel, kubeVersion, releaseNumberStr, imageDigests)
		if err != nil {
			return nil, errors.Wrapf(err, "Error getting bundle for eks-d %s-%s release bundle", channel, releaseNumberStr)
		}

		vsphereBundle, err := r.GetVsphereBundle(channel, imageDigests)
		if err != nil {
			return nil, errors.Wrapf(err, "Error getting bundle for vSphere infrastructure provider")
		}

		bottlerocketBootstrapBundle, err := r.GetBottlerocketBootstrapBundle(channel, releaseNumberStr, imageDigests)
		if err != nil {
			return nil, errors.Wrapf(err, "Error getting bundle for bottlerocket bootstrap")
		}

		versionsBundle := anywherev1alpha1.VersionsBundle{
			KubeVersion:            shortKubeVersion,
			EksD:                   eksDReleaseBundle,
			CertManager:            certManagerBundle,
			ClusterAPI:             coreClusterApiBundle,
			Bootstrap:              kubeadmBootstrapBundle,
			ControlPlane:           kubeadmControlPlaneBundle,
			Aws:                    awsBundle,
			VSphere:                vsphereBundle,
			Docker:                 dockerBundle,
			Eksa:                   eksaBundle,
			Cilium:                 ciliumBundle,
			Kindnetd:               kindnetdBundle,
			Flux:                   fluxBundle,
			ExternalEtcdBootstrap:  etcdadmBootstrapBundle,
			ExternalEtcdController: etcdadmControllerBundle,
			BottleRocketBootstrap:  bottlerocketBootstrapBundle,
			BottleRocketAdmin:      bottlerocketAdminBundle,
			Tinkerbell:             tinkerbellBundle,
		}
		versionsBundles = append(versionsBundles, versionsBundle)
	}
	return versionsBundles, nil
}