func ComputeForIntegration()

in pkg/util/digest/digest.go [48:157]
79 lines of code
29 McCabe index (conditional complexity)

func ComputeForIntegration(integration *v1.Integration, configmapVersions []string, secretVersions []string) (string, error) {
	hash := sha256.New()
	// Integration version is relevant
	if _, err := hash.Write([]byte(integration.Status.Version)); err != nil {
		return "", err
	}

	// Integration operator id is relevant
	if _, err := hash.Write([]byte(v1.GetOperatorIDAnnotation(integration))); err != nil {
		return "", err
	}

	// Integration profile is relevant
	if _, err := hash.Write([]byte(v1.GetIntegrationProfileAnnotation(integration))); err != nil {
		return "", err
	}
	if _, err := hash.Write([]byte(v1.GetIntegrationProfileNamespaceAnnotation(integration))); err != nil {
		return "", err
	}

	// Integration Kit is relevant
	if integration.Spec.IntegrationKit != nil {
		if _, err := hash.Write([]byte(fmt.Sprintf("%s/%s", integration.Spec.IntegrationKit.Namespace, integration.Spec.IntegrationKit.Name))); err != nil {
			return "", err
		}
	}
	// Profile is relevant
	if _, err := hash.Write([]byte(integration.Spec.Profile)); err != nil {
		return "", err
	}

	// Integration code
	for _, s := range integration.Spec.Sources {
		if s.Content != "" {
			if _, err := hash.Write([]byte(s.Content)); err != nil {
				return "", err
			}
		}
	}

	// Integration flows
	if len(integration.Spec.Flows) > 0 {
		flows, err := v1.ToYamlDSL(integration.Spec.Flows)
		if err != nil {
			return "", err
		}
		if _, err := hash.Write(flows); err != nil {
			return "", err
		}
	}

	// Integration dependencies
	for _, item := range integration.Spec.Dependencies {
		if _, err := hash.Write([]byte(item)); err != nil {
			return "", err
		}
	}

	// Integration configuration
	for _, item := range integration.Spec.Configuration {
		if _, err := hash.Write([]byte(item.String())); err != nil {
			return "", err
		}
	}

	// Git spec
	if integration.Spec.Git != nil {
		if _, err := hash.Write([]byte(integration.Spec.Git.URL + "/" + integration.Spec.Git.Secret)); err != nil {
			return "", err
		}
	}

	// Integration traits
	// Calculation logic prior to 1.10.0 (the new Traits API schema) is maintained
	// in order to keep consistency in the digest calculated from the same set of
	// Trait configurations for backward compatibility.
	if err := computeForTraits(hash, integration.Spec.Traits); err != nil {
		return "", err
	}

	// Integration traits as annotations
	for _, k := range sortedTraitAnnotationsKeys(integration) {
		v := integration.Annotations[k]
		if _, err := hash.Write([]byte(fmt.Sprintf("%s=%v,", k, v))); err != nil {
			return "", err
		}
	}

	// Configmap versions
	for _, cm := range configmapVersions {
		if cm != "" {
			if _, err := hash.Write([]byte(cm)); err != nil {
				return "", err
			}
		}
	}

	// Secret versions
	for _, s := range secretVersions {
		if s != "" {
			if _, err := hash.Write([]byte(s)); err != nil {
				return "", err
			}
		}
	}

	// Add a letter at the beginning and use URL safe encoding
	digest := "v" + base64.RawURLEncoding.EncodeToString(hash.Sum(nil))
	return digest, nil
}