Implement Kpt Function Conditional Rendering (Nephio #1084)

Author: SurbhiAgarwal1

internal/fnruntime/condition_test.go

@@ -0,0 +1,117 @@
+// Copyright 2026 The kpt and Nephio Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fnruntime
+
+import (
+	"context"
+	"io"
+	"testing"
+
+	"github.com/kptdev/kpt/internal/types"
+	fnresult "github.com/kptdev/kpt/pkg/api/fnresult/v1"
+	kptfile "github.com/kptdev/kpt/pkg/api/kptfile/v1"
+	"github.com/kptdev/kpt/pkg/lib/runneroptions"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sigs.k8s.io/kustomize/kyaml/filesys"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
+)
+
+func TestFunctionRunner_Conditions(t *testing.T) {
+	ctx := context.Background()
+	fsys := filesys.MakeFsInMemory()
+	celEnv, err := runneroptions.NewCELEnvironment()
+	require.NoError(t, err)
+
+	inputNodes := []*yaml.RNode{
+		yaml.MustParse("apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: app-config"),
+	}
+
+	testCases := []struct {
+		name      string
+		fn        *kptfile.Function
+		condition string
+		expectRun bool
+	}{
+		{
+			name: "builtin runtime - condition met",
+			fn: &kptfile.Function{
+				Image: runneroptions.FuncGenPkgContext,
+			},
+			condition: "resources.exists(r, r.kind == 'ConfigMap')",
+			expectRun: true,
+		},
+		{
+			name: "builtin runtime - condition not met",
+			fn: &kptfile.Function{
+				Image: runneroptions.FuncGenPkgContext,
+			},
+			condition: "resources.exists(r, r.kind == 'Deployment')",
+			expectRun: false,
+		},
+		{
+			name: "executable runtime - condition met",
+			fn: &kptfile.Function{
+				Exec: "my-exec",
+			},
+			condition: "resources.size() > 0",
+			expectRun: true,
+		},
+		{
+			name: "executable runtime - condition not met",
+			fn: &kptfile.Function{
+				Exec: "my-exec",
+			},
+			condition: "resources.size() == 0",
+			expectRun: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			tc.fn.Condition = tc.condition
+			results := fnresult.NewResultList()
+			
+			// Mock runner options
+			opts := runneroptions.RunnerOptions{
+				CELEnvironment: celEnv,
+				ResolveToImage: func(image string) string { return image },
+			}
+
+			// We use a mock runner to avoid actual execution
+			runner, err := NewRunner(ctx, fsys, tc.fn, types.UniquePath("pkg"), results, opts, nil)
+			require.NoError(t, err)
+
+			// Override the Run function to track if it's called
+			wasRun := false
+			runner.filter.Run = func(r io.Reader, w io.Writer) error {
+				wasRun = true
+				return nil
+			}
+
+			_, err = runner.Filter(inputNodes)
+			require.NoError(t, err)
+
+			assert.Equal(t, tc.expectRun, wasRun, "Run state mismatch for: %s", tc.name)
+			assert.Equal(t, !tc.expectRun, runner.WasSkipped(), "Skip state mismatch for: %s", tc.name)
+			
+			if !tc.expectRun {
+				require.NotEmpty(t, results.Items)
+				assert.True(t, results.Items[0].Skipped)
+				assert.Equal(t, 0, results.Items[0].ExitCode)
+			}
+		})
+	}
+}

internal/fnruntime/runner.go

@@ -212,6 +212,16 @@ type FunctionRunner struct {
 	opts             runneroptions.RunnerOptions
 	condition        string                          // CEL condition expression
 	celEnv           *runneroptions.CELEnvironment   // shared CEL environment for condition evaluation
+	skipped          bool                            // true if function execution was skipped due to condition
+}
+
+func (fr *FunctionRunner) SetCondition(condition string, celEnv *runneroptions.CELEnvironment) {
+	fr.condition = condition
+	fr.celEnv = celEnv
+}
+
+func (fr *FunctionRunner) WasSkipped() bool {
+	return fr.skipped
 }
 
 func (fr *FunctionRunner) Filter(input []*yaml.RNode) (output []*yaml.RNode, err error) {
@@ -230,8 +240,10 @@ func (fr *FunctionRunner) Filter(input []*yaml.RNode) (output []*yaml.RNode, err
 			}
 			// Append a skipped result so consumers get one result per pipeline step
 			fr.fnResult.ExitCode = 0
+			fr.fnResult.Skipped = true
 			fr.fnResults.Items = append(fr.fnResults.Items, *fr.fnResult)
 			// Return input unchanged - function is skipped
+			fr.skipped = true
 			return input, nil
 		}
 	}

internal/util/render/executor.go

@@ -812,7 +812,9 @@ func (pn *pkgNode) runMutators(ctx context.Context, hctx *hydrationContext, inpu
 			hctx.mutationSteps = append(hctx.mutationSteps, captureStepResult(pl.Mutators[i], hctx.fnResults, resultCountBeforeExec, err))
 			return input, err
 		}
-		hctx.executedFunctionCnt++
+		if !mutator.WasSkipped() {
+			hctx.executedFunctionCnt++
+		}
 		hctx.mutationSteps = append(hctx.mutationSteps, captureStepResult(pl.Mutators[i], hctx.fnResults, resultCountBeforeExec, nil))
 
 		if len(selectors) > 0 || len(exclusions) > 0 {
@@ -870,11 +872,14 @@ func (pn *pkgNode) runValidators(ctx context.Context, hctx *hydrationContext, in
 			hctx.validationSteps = append(hctx.validationSteps, preExecFailureStep(function, err))
 			return err
 		}
-		if _, err = validator.Filter(cloneResources(selectedResources)); err != nil {
+		validatorRunner := validator.(*fnruntime.FunctionRunner)
+		if _, err = validatorRunner.Filter(cloneResources(selectedResources)); err != nil {
 			hctx.validationSteps = append(hctx.validationSteps, captureStepResult(function, hctx.fnResults, resultCountBeforeExec, err))
 			return err
 		}
-		hctx.executedFunctionCnt++
+		if !validatorRunner.WasSkipped() {
+			hctx.executedFunctionCnt++
+		}
 		hctx.validationSteps = append(hctx.validationSteps, captureStepResult(function, hctx.fnResults, resultCountBeforeExec, nil))
 	}
 	return nil
@@ -1059,9 +1064,10 @@ func captureStepResult(fn kptfilev1.Function, fnResults *fnresult.ResultList, re
 		step.Stderr = last.Stderr
 		step.ExitCode = last.ExitCode
 		step.Results = frameworkResultsToItems(last.Results)
-		for _, ri := range step.Results {
-			if ri.Severity == string(framework.Error) {
-				step.ErrorResults = append(step.ErrorResults, ri)
+		step.Skipped = last.Skipped
+		for _, item := range step.Results {
+			if item.Severity == string(framework.Error) {
+				step.ErrorResults = append(step.ErrorResults, item)
 			}
 		}
 	} else if execErr != nil {

pkg/api/fnresult/v1/types.go

@@ -39,6 +39,8 @@ type Result struct {
 	ExitCode int `yaml:"exitCode"`
 	// Results is the list of results for the function
 	Results framework.Results `yaml:"results,omitempty"`
+	// Skipped indicates if the function was skipped due to a condition
+	Skipped bool `yaml:"skipped,omitempty"`
 }
 
 const (

pkg/api/kptfile/v1/types.go

@@ -447,6 +447,8 @@ type PipelineStepResult struct {
 	ExitCode       int          `yaml:"exitCode" json:"exitCode"`
 	Results        []ResultItem `yaml:"results,omitempty" json:"results,omitempty"`
 	ErrorResults   []ResultItem `yaml:"errorResults,omitempty" json:"errorResults,omitempty"`
+	// Skipped indicates if the function was skipped due to a condition
+	Skipped bool `yaml:"skipped,omitempty" json:"skipped,omitempty"`
 }
 
 // ResultItem mirrors framework.Result with only the fields needed for Kptfile status.

thirdparty/cmdconfig/commands/cmdeval/cmdeval.go

@@ -117,6 +117,8 @@ func GetEvalFnRunner(ctx context.Context, parent string) *EvalFnRunner {
 		&r.excludeAnnotations, "exclude-annotations", []string{}, "exclude resources matching the given annotations")
 	r.Command.Flags().StringArrayVar(
 		&r.excludeLabels, "exclude-labels", []string{}, "exclude resources matching the given labels")
+	r.Command.Flags().StringVar(
+		&r.Condition, "condition", "", "conditional expression to determine if function should be run")
 
 	if err := r.Command.Flags().MarkHidden("include-meta-resources"); err != nil {
 		panic(err)
@@ -161,6 +163,8 @@ type EvalFnRunner struct {
 	excludeLabels       []string
 	excludeAnnotations  []string
 
+	Condition string
+
 	runFns runfn.RunFns
 }
 
@@ -202,6 +206,7 @@ func (r *EvalFnRunner) NewFunction() *kptfile.Function {
 	if !r.Exclusion.IsEmpty() {
 		newFn.Exclusions = []kptfile.Selector{r.Exclusion}
 	}
+	newFn.Condition = r.Condition
 	if r.FnConfigPath != "" {
 		fnConfigAbsPath, _, _ := pathutil.ResolveAbsAndRelPaths(r.FnConfigPath)
 		pkgAbsPath, _, _ := pathutil.ResolveAbsAndRelPaths(r.runFns.Path)
@@ -556,6 +561,7 @@ func (r *EvalFnRunner) preRunE(c *cobra.Command, args []string) error {
 		ContinueOnEmptyResult: true,
 		Selector:              r.Selector,
 		Exclusion:             r.Exclusion,
+		Condition:             r.Condition,
 		RunnerOptions:         r.RunnerOptions,
 	}
 

thirdparty/kyaml/runfn/runfn.go

@@ -97,6 +97,7 @@ type RunFns struct {
 	Selector kptfile.Selector
 
 	Exclusion kptfile.Selector
+	Condition string
 }
 
 // Execute runs the command
@@ -413,5 +414,9 @@ func (r *RunFns) defaultFnFilterProvider(spec runtimeutil.FunctionSpec, fnConfig
 		opts.DisplayResourceCount = true
 	}
 
-	return fnruntime.NewFunctionRunner(r.Ctx, fltr, "", fnResult, r.fnResults, opts)
+	runner, _ := fnruntime.NewFunctionRunner(r.Ctx, fltr, "", fnResult, r.fnResults, opts)
+	if r.Condition != "" {
+		runner.SetCondition(r.Condition, opts.CELEnvironment)
+	}
+	return runner, nil
 }