func enqueueRequestsFromConfigFunc()

in pkg/controller/integration/integration_controller.go [178:239]
53 lines of code
17 McCabe index (conditional complexity)

func enqueueRequestsFromConfigFunc(ctx context.Context, c client.Client, res ctrl.Object) []reconcile.Request {
	requests := make([]reconcile.Request, 0)

	var storageType utilResource.StorageType

	switch res.(type) {
	case *corev1.ConfigMap:
		storageType = utilResource.StorageTypeConfigmap
	case *corev1.Secret:
		storageType = utilResource.StorageTypeSecret
	default:
		return requests
	}

	// Do global search in case of global operator (it may be using a global platform)
	list := &v1.IntegrationList{}

	opts := make([]ctrl.ListOption, 0)
	if !platform.IsCurrentOperatorGlobal() {
		opts = append(opts, ctrl.InNamespace(res.GetNamespace()))
	}

	if err := c.List(ctx, list, opts...); err != nil {
		log.Error(err, "Failed to list integrations")
		return requests
	}

	for _, integration := range list.Items {
		found := false
		if integration.Spec.Traits.Mount == nil || !ptr.Deref(integration.Spec.Traits.Mount.HotReload, false) {
			continue
		}
		for _, c := range integration.Spec.Traits.Mount.Configs {
			if conf, parseErr := utilResource.ParseConfig(c); parseErr == nil {
				if conf.StorageType() == storageType && conf.Name() == res.GetName() {
					found = true
					break
				}
			}
		}
		for _, r := range integration.Spec.Traits.Mount.Resources {
			if conf, parseErr := utilResource.ParseConfig(r); parseErr == nil {
				if conf.StorageType() == storageType && conf.Name() == res.GetName() {
					found = true
					break
				}
			}
		}

		if found {
			log.Infof("%s %s updated, wake-up integration: %s", res.GetObjectKind(), res.GetName(), integration.Name)
			requests = append(requests, reconcile.Request{
				NamespacedName: types.NamespacedName{
					Namespace: integration.Namespace,
					Name:      integration.Name,
				},
			})
		}
	}

	return requests
}