Treat all errors encountered while patching as fatal

This will stop the reconcile. No further patches, resources, or
functions will be processed.

This commit breaks required field paths, in that we'll return a fatal
result if a required field path is missing. This means a set of patches
that could have been eventually consistent now cannot. I intend to
address that in a following commit.

Signed-off-by: Nic Cope <nicc@rk0n.org>

Author: negz

fn.go

@@ -192,17 +192,13 @@ func (f *Function) RunFunction(ctx context.Context, req *fnv1beta1.RunFunctionRe
 				"name", ocd.Resource.GetName())
 		}
 
-		errs, store := RenderComposedPatches(ocd.Resource, dcd.Resource, oxr.Resource, dxr.Resource, env, t.Patches)
-		for _, err := range errs {
-			response.Warning(rsp, errors.Wrapf(err, "cannot render patches for composed resource %q", t.Name))
-			log.Info("Cannot render patches for composed resource", "warning", err)
-			warnings++
+		// TODO(negz): No need for multiple errors?
+		if err := RenderComposedPatches(ocd.Resource, dcd.Resource, oxr.Resource, dxr.Resource, env, t.Patches); err != nil {
+			response.Fatal(rsp, errors.Wrapf(err, "cannot render patches for composed resource %q", t.Name))
+			return rsp, nil
 		}
 
-		if store {
-			// Add or replace our desired resource.
-			desired[resource.Name(t.Name)] = dcd
-		}
+		desired[resource.Name(t.Name)] = dcd
 	}
 
 	if err := response.SetDesiredCompositeResource(rsp, dxr); err != nil {

fn_test.go

@@ -406,18 +406,10 @@ func TestRunFunction(t *testing.T) {
 									},
 									{
 										// This patch should return an error,
-										// because the required path does not
-										// exist.
+										// because the path is not an array.
 										Type: v1beta1.PatchTypeFromCompositeFieldPath,
 										Patch: v1beta1.Patch{
-											FromFieldPath: ptr.To[string]("spec.doesNotExist"),
-											ToFieldPath:   ptr.To[string]("spec.explode"),
-											Policy: &v1beta1.PatchPolicy{
-												FromFieldPath: func() *v1beta1.FromFieldPathPolicy {
-													r := v1beta1.FromFieldPathPolicyRequired
-													return &r
-												}(),
-											},
+											FromFieldPath: ptr.To[string]("spec.widgets[0]"),
 										},
 									},
 								},
@@ -458,11 +450,10 @@ func TestRunFunction(t *testing.T) {
 					},
 					Results: []*fnv1beta1.Result{
 						{
-							Severity: fnv1beta1.Severity_SEVERITY_WARNING,
-							Message:  fmt.Sprintf("cannot render patches for composed resource %q: cannot apply the %q patch at index 1: spec.doesNotExist: no such field", "cool-resource", "FromCompositeFieldPath"),
+							Severity: fnv1beta1.Severity_SEVERITY_FATAL,
+							Message:  fmt.Sprintf("cannot render patches for composed resource %q: cannot apply the %q patch at index 1: spec.widgets: not an array", "cool-resource", "FromCompositeFieldPath"),
 						},
 					},
-					Context: &structpb.Struct{Fields: map[string]*structpb.Value{fncontext.KeyEnvironment: structpb.NewStructValue(nil)}},
 				},
 			},
 		},

render.go

@@ -85,14 +85,7 @@ func RenderEnvironmentPatches(env *unstructured.Unstructured, oxr, dxr *composit
 // patches that are to or from the supplied composite resource and environment
 // in the order they were defined. Properly selecting the right source or
 // destination between observed and desired resources.
-func RenderComposedPatches( //nolint:gocyclo // just a switch
-	ocd *composed.Unstructured,
-	dcd *composed.Unstructured,
-	oxr *composite.Unstructured,
-	dxr *composite.Unstructured,
-	env *unstructured.Unstructured,
-	ps []v1beta1.ComposedPatch,
-) (errs []error, store bool) {
+func RenderComposedPatches(ocd, dcd *composed.Unstructured, oxr, dxr *composite.Unstructured, env *unstructured.Unstructured, ps []v1beta1.ComposedPatch) error { //nolint:gocyclo // just a switch
 	for i, p := range ps {
 		p := p
 		switch t := p.GetType(); t {
@@ -112,7 +105,7 @@ func RenderComposedPatches( //nolint:gocyclo // just a switch
 				continue
 			}
 			if err := ApplyToObjects(&p, dxr, ocd); err != nil {
-				errs = append(errs, errors.Wrapf(err, errFmtPatch, t, i))
+				return errors.Wrapf(err, errFmtPatch, t, i)
 			}
 		case v1beta1.PatchTypeToEnvironmentFieldPath, v1beta1.PatchTypeCombineToEnvironment:
 			// TODO(negz): Same as above, but for the Environment. What does it
@@ -125,7 +118,7 @@ func RenderComposedPatches( //nolint:gocyclo // just a switch
 				continue
 			}
 			if err := ApplyToObjects(&p, env, ocd); err != nil {
-				errs = append(errs, errors.Wrapf(err, errFmtPatch, t, i))
+				return errors.Wrapf(err, errFmtPatch, t, i)
 			}
 		// If either of the below renderings return an error, most likely a
 		// required FromComposite or FromEnvironment patch failed. A required
@@ -135,17 +128,15 @@ func RenderComposedPatches( //nolint:gocyclo // just a switch
 		// resource to our accumulated desired state.
 		case v1beta1.PatchTypeFromCompositeFieldPath, v1beta1.PatchTypeCombineFromComposite:
 			if err := ApplyToObjects(&p, oxr, dcd); err != nil {
-				errs = append(errs, errors.Wrapf(err, errFmtPatch, t, i))
-				return errs, false
+				return errors.Wrapf(err, errFmtPatch, t, i)
 			}
 		case v1beta1.PatchTypeFromEnvironmentFieldPath, v1beta1.PatchTypeCombineFromEnvironment:
 			if err := ApplyToObjects(&p, env, dcd); err != nil {
-				errs = append(errs, errors.Wrapf(err, errFmtPatch, t, i))
-				return errs, false
+				return errors.Wrapf(err, errFmtPatch, t, i)
 			}
 		case v1beta1.PatchTypePatchSet:
 			// Already resolved - nothing to do.
 		}
 	}
-	return errs, true
+	return nil
 }