func()

in pkg/operator/collection.go [273:336]
52 lines of code
13 McCabe index (conditional complexity)

func (r *collectionReconciler) ensureCollectorConfig(ctx context.Context, spec *monitoringv1.CollectionSpec, compression monitoringv1.CompressionType, exports []monitoringv1.ExportSpec) error {
	cfg, updates, err := r.makeCollectorConfig(ctx, spec, exports)
	if err != nil {
		return fmt.Errorf("generate Prometheus config: %w", err)
	}

	var credentialsFile string
	if spec.Credentials != nil {
		credentialsFile = path.Join(secretsDir, pathForSelector(r.opts.PublicNamespace, &monitoringv1.SecretOrConfigMap{Secret: spec.Credentials}))
	}

	cfg.GoogleCloud = &GoogleCloudConfig{
		Export: &GoogleCloudExportConfig{
			Compression:     ptr.To(string(compression)),
			CredentialsFile: ptr.To(credentialsFile),
			Match:           spec.Filter.MatchOneOf,
		},
	}

	cfgEncoded, err := yaml.Marshal(cfg)
	if err != nil {
		return fmt.Errorf("marshal Prometheus config: %w", err)
	}

	cm := &corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: r.opts.OperatorNamespace,
			Name:      NameCollector,
		},
	}
	if err := setConfigMapData(cm, compression, configFilename, string(cfgEncoded)); err != nil {
		return err
	}

	if err := r.client.Update(ctx, cm); apierrors.IsNotFound(err) {
		if err := r.client.Create(ctx, cm); err != nil {
			return fmt.Errorf("create Prometheus config: %w", err)
		}
	} else if err != nil {
		return fmt.Errorf("update Prometheus config: %w", err)
	}

	// Reconcile any status updates.
	var errs []error
	for _, update := range updates {
		// Copy status in case we update both spec and status. Updating one reverts the other.
		statusUpdate := update.object.DeepCopyObject().(monitoringv1.MonitoringCRD).GetMonitoringStatus()
		if update.spec {
			// The status will be reverted, but our generation ID will be updated.
			if err := r.client.Update(ctx, update.object); err != nil {
				errs = append(errs, err)
			}
		}

		if update.status {
			// Use the object with the latest generation ID.
			if err := patchMonitoringStatus(ctx, r.client, update.object, statusUpdate); err != nil {
				errs = append(errs, err)
			}
		}
	}

	return errors.Join(errs...)
}