func()

in internal/controllers/resourceslice/slicecleanup.go [74:128]

• 46 lines of code
• 11 McCabe index (conditional complexity)

func (c *cleanupController) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	logger := logr.FromContextOrDiscard(ctx).WithValues("resourceSliceName", req.Name, "resourceSliceNamespace", req.Namespace)

	slice := &apiv1.ResourceSlice{}
	err := c.client.Get(ctx, req.NamespacedName, slice)
	if errors.IsNotFound(err) {
		return ctrl.Result{}, nil
	}
	if err != nil {
		logger.Error(err, "failed to get resource slice")
		return ctrl.Result{}, err
	}
	logger = logger.WithValues("synthesisUUID", slice.Spec.SynthesisUUID)

	owner := metav1.GetControllerOf(slice)
	if owner != nil {
		logger = logger.WithValues("compositionName", owner.Name, "compositionNamespace", req.Namespace)
	}
	ctx = logr.NewContext(ctx, logger)

	if slice.DeletionTimestamp != nil {
		return c.removeFinalizer(ctx, slice, owner)
	}

	// Don't bother checking on brand new resource slices
	if delta := time.Since(slice.CreationTimestamp.Time); delta < 5*time.Second {
		return ctrl.Result{RequeueAfter: delta}, nil
	}

	del, err := c.shouldDelete(ctx, c.client, slice, owner)
	if err != nil {
		logger.Error(err, "failed to check if resource slice should be deleted (cached)")
		return ctrl.Result{}, err
	}
	if !del {
		return ctrl.Result{}, nil // fail safe for stale cache
	}

	del, err = c.shouldDelete(ctx, c.noCacheReader, slice, owner)
	if err != nil {
		logger.Error(err, "failed to check if resource slice should be deleted")
		return ctrl.Result{}, err
	}
	if !del {
		return ctrl.Result{}, nil
	}

	if err := c.client.Delete(ctx, slice, &client.Preconditions{UID: &slice.UID}); err != nil {
		logger.Error(err, "failed to delete resource slice")
		return ctrl.Result{}, err
	}
	logger.V(0).Info("deleted unused resource slice", "age", time.Since(slice.CreationTimestamp.Time).Milliseconds())

	return ctrl.Result{}, nil
}