func run()

in operator/scripts/generate-image-configmap/main.go [58:184]
115 lines of code
30 McCabe index (conditional complexity)

func run(ctx context.Context) error {
	log := klog.FromContext(ctx)

	cc := &corev1beta1.ConfigConnector{
		Spec: corev1beta1.ConfigConnectorSpec{
			Mode:                 k8s.NamespacedMode,
			GoogleServiceAccount: "someGSA",
		},
	}
	operatorSrcRoot := paths.GetOperatorSrcRootOrLogFatal()
	r := cnrmmanifest.NewLocalRepository(path.Join(operatorSrcRoot, "channels"))
	channel, err := r.LoadChannel(ctx, k8s.StableChannel)
	if err != nil {
		return fmt.Errorf("error loading %v channel: %w", k8s.StableChannel, err)
	}
	version, err := channel.Latest(ctx, cc.ComponentName())
	if err != nil {
		return fmt.Errorf("error resolving the version to deploy: %w", err)
	}
	if version == nil {
		return fmt.Errorf("could not find the latest version in channel %v", k8s.StableChannel)
	}

	log.Info("got latest version from channel", "version", version.Version)
	manifestStrs, err := r.LoadManifest(ctx, cc.ComponentName(), version.Version, cc)
	if err != nil {
		return fmt.Errorf("error loading manifest for package %v of version %v: %w", version.Package, version.Version, err)
	}
	objects := make([]*manifest.Object, 0)
	for _, str := range manifestStrs {
		m, err := manifest.ParseObjects(ctx, str)
		if err != nil {
			return fmt.Errorf("parsing manifest: %w", err)
		}
		objects = append(objects, m.Items...)
	}

	namespacedStrs, err := r.LoadNamespacedComponents(ctx, cc.ComponentName(), version.Version)
	if err != nil {
		return fmt.Errorf("error loading namespaced components for package %v of version %v: %w", version.Package, version.Version, err)
	}
	for _, str := range namespacedStrs {
		m, err := manifest.ParseObjects(ctx, str)
		if err != nil {
			return fmt.Errorf("parsing manifest: %w", err)
		}
		objects = append(objects, m.Items...)
	}

	cm := corev1.ConfigMap{
		TypeMeta: metav1.TypeMeta{
			Kind:       "ConfigMap",
			APIVersion: "v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      "config-images",
			Namespace: k8s.OperatorSystemNamespace,
			Labels: map[string]string{
				"addonmanager.kubernetes.io/mode":       "Reconcile",
				"cnrm.cloud.google.com/operator-system": "true",
			},
			Annotations: map[string]string{
				"components.gke.io/image-map": "Images deployed by operator",
			},
		},
		Data: make(map[string]string, 0),
	}

	for _, obj := range objects {
		log.Info("found object", "kind", obj.Kind, "name", obj.GetName())

		// controller image
		if obj.Kind == "StatefulSet" && strings.Contains(obj.GetName(), "cnrm-controller-manager") {
			image, err := extractImageFromStatefulSet(obj.UnstructuredObject(), "manager")
			if err != nil {
				return fmt.Errorf("error resolving manager image: %w", err)
			}
			cm.Data["cnrm.controller"] = image
		}
		// deletion defender image
		if obj.Kind == "StatefulSet" && obj.GetName() == "cnrm-deletiondefender" {
			image, err := extractImageFromStatefulSet(obj.UnstructuredObject(), "deletiondefender")
			if err != nil {
				return fmt.Errorf("error resolving manager image: %w", err)
			}
			cm.Data["cnrm.deletiondefender"] = image
		}
		// unmanaged detector image
		if obj.Kind == "StatefulSet" && obj.GetName() == "cnrm-unmanaged-detector" {
			image, err := extractImageFromStatefulSet(obj.UnstructuredObject(), "unmanageddetector")
			if err != nil {
				return fmt.Errorf("error resolving manager image: %w", err)
			}
			cm.Data["cnrm.unmanageddetector"] = image
		}
		// webhook image
		if obj.Kind == "Deployment" && obj.GetName() == "cnrm-webhook-manager" {
			image, err := extractImageFromDeployment(obj.UnstructuredObject(), "webhook")
			if err != nil {
				return fmt.Errorf("error resolving webhook image: %w", err)
			}
			cm.Data["cnrm.webhook"] = image
		}
		// recorder image
		if obj.Kind == "Deployment" && obj.GetName() == "cnrm-resource-stats-recorder" {
			image, err := extractImageFromDeployment(obj.UnstructuredObject(), "recorder")
			if err != nil {
				return fmt.Errorf("error resolving recorder image: %w", err)
			}
			cm.Data["cnrm.recorder"] = image
		}
		// prom-to-sd sidecar image
		if obj.Kind == "Deployment" && obj.GetName() == "cnrm-resource-stats-recorder" {
			image, err := extractImageFromDeployment(obj.UnstructuredObject(), "prom-to-sd")
			if err != nil {
				return fmt.Errorf("error resolving prom-to-sd sidecar image: %w", err)
			}
			cm.Data["prom-to-sd"] = image
		}
	}
	outputFilepath := path.Join(operatorSrcRoot, outputDir, outputFilename)
	if err := outputConfigMapToFile(&cm, outputFilepath); err != nil {
		return fmt.Errorf("error writing ConfigMap %v to file: %w", cm, err)
	}
	log.Info("successfully generated the image configmap", "path", outputFilepath)
	return nil
}