add ability to declare Dependency in tests

Signed-off-by: Alay Patel <[email protected]>

Author: alaypatel07

clusterloader2/api/types.go

@@ -43,6 +43,9 @@ type TestScenario struct {
 type Config struct {
 	// Name of the test case.
 	Name string `json:"name"`
+	// Dependencies is a list of dependencies that must be set up before steps begin
+	// and torn down after test completion.
+	Dependencies []*Dependency `json:"dependencies,omitempty"`
 	// TODO(#1696): Clean up after removing automanagedNamespaces
 	AutomanagedNamespaces int32 `json:"automanagedNamespaces,omitempty"`
 	// Namespace is a structure for namespace configuration.
@@ -222,6 +225,21 @@ type Measurement struct {
 	Instances []*MeasurementInstanceConfig
 }
 
+// Dependency defines the dependency which will call either install or teardown process for configuring cluster
+// dependencies.
+type Dependency struct {
+	// Name is a human-readable name for this dependency instance.
+	Name string `json:"name"`
+	// Method is a name of a method registered in the ClusterLoader dependency factory.
+	Method string `json:"method"`
+	// Timeout is the maximum duration for both setup and teardown operations.
+	// If set to 0, operations will wait forever.
+	Timeout Duration `json:"timeout,omitempty"`
+	// Params is a map of {name: value} pairs which will be passed to the dependency method - allowing for injection
+	// of arbitrary parameters to it.
+	Params map[string]interface{} `json:"params"`
+}
+
 // QPSLoad starts one operation every 1/QPS seconds.
 type QPSLoad struct {
 	// QPS specifies requested qps.

clusterloader2/api/validation.go

@@ -51,6 +51,10 @@ func (v *ConfigValidator) Validate() *errors.ErrorList {
 
 	allErrs = append(allErrs, v.validateNamespace(&c.Namespace, field.NewPath("namespace"))...)
 
+	for i := range c.Dependencies {
+		allErrs = append(allErrs, v.validateDependency(c.Dependencies[i], field.NewPath("dependencies").Index(i))...)
+	}
+
 	for i := range c.TuningSets {
 		allErrs = append(allErrs, v.validateTuningSet(c.TuningSets[i], field.NewPath("tuningSets").Index(i))...)
 	}
@@ -297,6 +301,20 @@ func (v *ConfigValidator) validatePoissonLoad(rl *PoissonLoad, fldPath *field.Pa
 	return allErrs
 }
 
+func (v *ConfigValidator) validateDependency(d *Dependency, fldPath *field.Path) field.ErrorList {
+	allErrs := field.ErrorList{}
+	if d.Name == "" {
+		allErrs = append(allErrs, field.Required(fldPath.Child("name"), "name is required"))
+	}
+	if d.Method == "" {
+		allErrs = append(allErrs, field.Required(fldPath.Child("method"), "method is required"))
+	}
+	if d.Timeout < 0 {
+		allErrs = append(allErrs, field.Invalid(fldPath.Child("timeout"), d.Timeout, "timeout cannot be negative"))
+	}
+	return allErrs
+}
+
 func (v *ConfigValidator) fileExists(path string) bool {
 	cwd, _ := os.Getwd()
 	_, err := os.Stat(fmt.Sprintf("%s/%s/%s", cwd, v.configDir, path))

clusterloader2/api/validation_test.go

@@ -358,6 +358,84 @@ func TestVerifyMeasurement(t *testing.T) {
 	}
 }
 
+func TestVerifyDependency(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		input    Dependency
+		expected bool
+	}{
+		{
+			name: "Valid dependency - name and method specified",
+			input: Dependency{
+				Name:    "test-dependency",
+				Method:  "TestMethod",
+				Timeout: Duration(300000000000), // 5 minutes in nanoseconds
+				Params: map[string]interface{}{
+					"param1": "value1",
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "Valid dependency - zero timeout",
+			input: Dependency{
+				Name:    "test-dependency",
+				Method:  "TestMethod",
+				Timeout: Duration(0),
+			},
+			expected: true,
+		},
+		{
+			name: "Valid dependency - minimal fields",
+			input: Dependency{
+				Name:   "test-dependency",
+				Method: "TestMethod",
+			},
+			expected: true,
+		},
+		{
+			name: "Invalid dependency - negative timeout",
+			input: Dependency{
+				Name:    "test-dependency",
+				Method:  "TestMethod",
+				Timeout: Duration(-1),
+			},
+			expected: false,
+		},
+		{
+			name: "Invalid dependency - missing name",
+			input: Dependency{
+				Method: "TestMethod",
+			},
+			expected: false,
+		},
+		{
+			name: "Invalid dependency - missing method",
+			input: Dependency{
+				Name: "test-dependency",
+			},
+			expected: false,
+		},
+		{
+			name: "Invalid dependency - both name and method missing",
+			input: Dependency{
+				Params: map[string]interface{}{
+					"param1": "value1",
+				},
+			},
+			expected: false,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			v := NewConfigValidator("", &Config{})
+			got := isValid(v.validateDependency(&test.input, field.NewPath("")))
+			if test.expected != got {
+				t.Errorf("wanted: %v, got: %v", test.expected, got)
+			}
+		})
+	}
+}
+
 func TestVerifyStep(t *testing.T) {
 	for _, test := range []struct {
 		name     string

clusterloader2/pkg/dependency/README.md

@@ -0,0 +1,83 @@
+# ClusterLoader2 Dependency System
+
+The dependency system in ClusterLoader2 allows you to install and manage cluster dependencies as part of your test configuration. Dependencies are now executed at the test level with explicit setup and teardown phases, providing better lifecycle management and error handling.
+
+## Overview
+
+Dependencies are executed in two phases:
+- **Setup Phase**: Dependencies are set up before any test steps begin execution
+- **Teardown Phase**: Dependencies are torn down after all test resources are cleaned up
+
+Key features:
+- Dependencies run before steps and are torn down after cleanup
+- Timeout enforcement for both setup and teardown operations  
+- If any dependency fails, the entire test workflow fails
+- Dependencies are torn down in reverse order of setup
+
+## New Usage Format
+
+Dependencies are now defined at the test level using the new name/method format:
+
+```yaml
+name: dra-steady-state
+dependencies:
+- name: install dra driver
+  method: DRAInstall 
+  timeout: 10m
+  params:
+    foo: bar
+steps:
+- name: step1
+  # ... step configuration
+```
+
+### Dependency Fields
+
+- `name` (required): A unique identifier for this dependency instance
+- `method` (required): The dependency method registered in the factory
+- `timeout` (optional): Maximum duration for both setup and teardown. If 0, operations wait forever
+- `params` (optional): Parameters passed to the dependency
+
+## Creating Custom Dependencies
+
+To create a custom dependency with the new interface:
+
+1. Create a new package under `pkg/dependency/`
+2. Implement the new `Dependency` interface:
+   ```go
+   type Dependency interface {
+       Setup(config *Config) error
+       Teardown(config *Config) error
+       String() string
+   }
+   ```
+
+3. Example implementation:
+   ```go
+   type myDependency struct{}
+   
+   func (d *myDependency) Setup(config *Config) error {
+       // Setup logic here
+       return nil
+   }
+   
+   func (d *myDependency) Teardown(config *Config) error {
+       // Teardown logic here  
+       return nil
+   }
+   
+   func (d *myDependency) String() string {
+       return "MyDependency"
+   }
+   ```
+
+4. Register your dependency in an `init()` function:
+   ```go
+   func init() {
+       if err := dependency.Register("MyDependency", createMyDependency); err != nil {
+           klog.Fatalf("Cannot register %s: %v", "MyDependency", err)
+       }
+   }
+   ```
+
+5. Import your dependency package in `cmd/clusterloader.go`

clusterloader2/pkg/dependency/factory.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2025 The Kubernetes 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 dependency
+
+import (
+	"fmt"
+	"sync"
+)
+
+// factory is a default global factory instance.
+var factory = newDependencyFactory()
+
+func newDependencyFactory() *dependencyFactory {
+	return &dependencyFactory{
+		createFuncs: make(map[string]createDependencyFunc),
+	}
+}
+
+// dependencyFactory is a factory that creates dependency instances.
+type dependencyFactory struct {
+	lock        sync.RWMutex
+	createFuncs map[string]createDependencyFunc
+}
+
+func (df *dependencyFactory) register(methodName string, createFunc createDependencyFunc) error {
+	df.lock.Lock()
+	defer df.lock.Unlock()
+	_, exists := df.createFuncs[methodName]
+	if exists {
+		return fmt.Errorf("dependency with method %v already exists", methodName)
+	}
+	df.createFuncs[methodName] = createFunc
+	return nil
+}
+
+func (df *dependencyFactory) createDependency(methodName string) (Dependency, error) {
+	df.lock.RLock()
+	defer df.lock.RUnlock()
+	createFunc, exists := df.createFuncs[methodName]
+	if !exists {
+		return nil, fmt.Errorf("unknown dependency method %s", methodName)
+	}
+	return createFunc(), nil
+}
+
+// Register registers create dependency function in dependency factory.
+func Register(methodName string, createFunc createDependencyFunc) error {
+	return factory.register(methodName, createFunc)
+}

clusterloader2/pkg/dependency/interface.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2025 The Kubernetes 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 dependency
+
+import (
+	"k8s.io/perf-tests/clusterloader2/pkg/config"
+	"k8s.io/perf-tests/clusterloader2/pkg/framework"
+	"k8s.io/perf-tests/clusterloader2/pkg/provider"
+
+	"k8s.io/apimachinery/pkg/version"
+)
+
+// Config provides client and parameters required for the dependency execution.
+type Config struct {
+	// ClusterFramework returns cluster framework.
+	ClusterFramework *framework.Framework
+	// PrometheusFramework returns prometheus framework.
+	PrometheusFramework *framework.Framework
+	// Params is a map of {name: value} pairs enabling for injection of arbitrary config
+	// into the Execute method.
+	Params map[string]interface{}
+	// TemplateProvider provides templated objects.
+	TemplateProvider    *config.TemplateProvider
+	ClusterLoaderConfig *config.ClusterLoaderConfig
+
+	// Method identifies this instance of dependency.
+	Method        string
+	CloudProvider provider.Provider
+
+	// ClusterVersion contains the version of the cluster and is used to select
+	// available features.
+	ClusterVersion version.Info
+}
+
+// Dependency is a common interface for all dependency methods. It should be implemented by the user to
+// allow dependency method to be registered in the dependency factory.
+type Dependency interface {
+	// Setup sets up the dependency and returns an error if setup fails.
+	Setup(config *Config) error
+	// Teardown tears down the dependency and returns an error if teardown fails.
+	Teardown(config *Config) error
+	// String returns a string representation of the dependency.
+	String() string
+}
+
+type createDependencyFunc func() Dependency