func()

in projects/aws/image-builder/builder/utils.go [255:347]
83 lines of code
20 McCabe index (conditional complexity)

func (bo *BuildOptions) getBundle() (*releasev1.Bundles, string, error) {
	manifestDirPath, err := getManifestRoot()
	if err != nil {
		return nil, "", err
	}

	eksAReleasesManifestURL, err := getEksAReleasesManifestURL(bo.AirGapped)
	if err != nil {
		return nil, "", err
	}
	var releasesManifestContents []byte
	if bo.ManifestTarball != "" {
		eksAManifestFile := filepath.Join(manifestDirPath, eksAnywhereManifestFileName)
		log.Printf("Reading EKS-A Manifest file: %s", eksAManifestFile)
		releasesManifestContents, err = os.ReadFile(eksAManifestFile)
		if err != nil {
			return nil, "", err
		}
	} else {
		log.Printf("Reading EKS-A Manifest file: %s", eksAReleasesManifestURL)
		releasesManifestContents, err = readFileFromURL(eksAReleasesManifestURL)
		if err != nil {
			return nil, "", err
		}
	}

	releases := &releasev1.Release{}
	if err = k8syaml.Unmarshal(releasesManifestContents, releases); err != nil {
		return nil, "", fmt.Errorf("failed to unmarshal release manifest from [%s]: %v", eksAReleasesManifestURL, err)
	}

	var eksAReleaseVersion, bundleManifestUrl string
	var foundRelease bool
	if os.Getenv(eksaUseDevReleaseEnvVar) == "true" {
		eksAReleaseVersion = releases.Spec.LatestVersion
		log.Printf("EKSA_USE_DEV_RELEASE set to true, using EKS-A dev release version: %s", eksAReleaseVersion)
	} else if bo.EKSAReleaseVersion != "" {
		eksAReleaseVersion = bo.EKSAReleaseVersion
		log.Printf("EKS-A release version provided: %s", eksAReleaseVersion)
	} else if eksaVersion != "" {
		eksAReleaseVersion = eksaVersion
		log.Printf("No EKS-A release version provided, defaulting to EKS-A version configured at build time: %s", eksAReleaseVersion)
	} else {
		eksAReleaseVersion = releases.Spec.LatestVersion
		log.Printf("No EKS-A release version provided, defaulting to latest EKS-A version: %s", eksAReleaseVersion)
	}

	for _, r := range releases.Spec.Releases {
		if r.Version == eksAReleaseVersion {
			foundRelease = true
			bundleManifestUrl = r.BundleManifestUrl
			break
		}
	}

	if !foundRelease {
		// if release was not found, this is probably a dev release version which we need
		// to use a prefix match to find since the version in the release.yaml
		// will be v0.0.0-dev+build.7423
		for _, r := range releases.Spec.Releases {
			if strings.Contains(r.Version, eksAReleaseVersion) {
				foundRelease = true
				bundleManifestUrl = r.BundleManifestUrl
				break
			}
		}
	}
	if !foundRelease {
		return nil, "", fmt.Errorf("version %s is not a valid EKS-A release", eksAReleaseVersion)
	}
	var bundleManifestContents []byte
	if bo.ManifestTarball == "" {
		log.Printf("Fetching git commit from bundle manifest: %s", bundleManifestUrl)
		bundleManifestContents, err = readFileFromURL(bundleManifestUrl)
		if err != nil {
			return nil, "", err
		}
	} else {
		bundleManifestFile := filepath.Join(manifestDirPath, fmt.Sprintf(eksAnywhereBundlesFileNameFormat, eksAReleaseVersion))
		log.Printf("Fetching git commit from bundle manifest: %s", bundleManifestFile)
		bundleManifestContents, err = os.ReadFile(bundleManifestFile)
		if err != nil {
			return nil, "", err
		}
	}

	bundles := &releasev1.Bundles{}
	if err = k8syaml.Unmarshal(bundleManifestContents, bundles); err != nil {
		return nil, "", fmt.Errorf("failed to unmarshal bundles manifest from [%s]: %v", bundleManifestUrl, err)
	}

	return bundles, eksAReleaseVersion, nil
}