func()

in pkg/csi/controller.go [148:224]
67 lines of code
17 McCabe index (conditional complexity)

func (r *reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	log := log.FromContext(ctx)

	var node corev1.Node
	if err := r.Get(ctx, req.NamespacedName, &node); err != nil {
		log.Error(err, "get node for reconcile", "node", req.NamespacedName.Name)
		r.deleteOrphanedPDs(ctx)
		return ctrl.Result{}, nil
	}

	if node.DeletionTimestamp != nil {
		r.deleteOrphanedPDs(ctx)
		// TODO: clean up old mappings?
		return ctrl.Result{}, nil
	}

	mustCreateMapping := false
	var mapping map[string]volumeTypeInfo
	var configMap corev1.ConfigMap
	err := r.Get(ctx, types.NamespacedName{Namespace: r.namespace, Name: r.volumeTypeConfigMap}, &configMap)
	if apierrors.IsNotFound(err) {
		mustCreateMapping = true
		configMap.SetNamespace(r.namespace)
		configMap.SetName(r.volumeTypeConfigMap)
		mapping = map[string]volumeTypeInfo{}
	} else if err == nil {
		if mapping, err = getVolumeTypeMapping(configMap.Data); err != nil {
			log.Error(err, "bad mapping (ignored, mapping recreated)")
			mapping = map[string]volumeTypeInfo{}
		}
	} else {
		log.Error(err, "get mapping", "mapping", fmt.Sprintf("%s/%s", r.namespace, r.volumeTypeConfigMap))
		return ctrl.Result{}, nil
	}

	if configMap.Data == nil {
		configMap.Data = map[string]string{}
	}

	info, err := getVolumeTypeFromNode(&node)
	if err != nil && strings.Contains(err.Error(), "label not found on node") {
		log.Info("skipping non-cache node", "node", node.GetName())
		return ctrl.Result{}, nil
	} else if err != nil {
		return ctrl.Result{}, err
	}

	if info.VolumeType == pdVolumeType {
		if r.pdStorageClass == "" {
			return ctrl.Result{}, fmt.Errorf("No PD storage class has been defined, PD volumes can't be used")
		}
		if err := r.updatePdVolumeType(ctx, node.GetName(), &info); err != nil {
			return ctrl.Result{}, err
		}
	}

	mapping[node.GetName()] = info
	if err := writeVolumeTypeMapping(configMap.Data, mapping); err != nil {
		log.Error(err, "write mapping", "node", node.GetName())
		return ctrl.Result{}, err

	}
	if mustCreateMapping {
		if err := r.Create(ctx, &configMap); err != nil {
			log.Error(err, "create configmap")
			return ctrl.Result{}, err // requeue
		}
	} else {
		if err := r.Update(ctx, &configMap); err != nil {
			log.Error(err, "update configmap")
			return ctrl.Result{}, err // requeue
		}
	}
	log.Info("update", "node", node.GetName(), "info", info)

	return ctrl.Result{}, nil
}