From ae1a9aff5b4aee5cd2e13b5e34d59f9d4a7ee14a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Kalke?= <56382792+MichalKalke@users.noreply.github.com> Date: Fri, 11 Aug 2023 11:23:10 +0200 Subject: [PATCH] expose aditional config into serverless cr (#192) Co-authored-by: Damian Badura <45110612+dbadura@users.noreply.github.com> --- api/v1alpha1/serverless_helpers.go | 2 +- api/v1alpha1/serverless_types.go | 25 +++- ...operator.kyma-project.io_serverlesses.yaml | 36 ++++++ controllers/serverless_controller_test.go | 2 +- controllers/testhelper_test.go | 2 +- internal/chart/flags.go | 18 ++- internal/chart/flags_test.go | 24 ---- internal/state/optional_dependencies.go | 107 ++++++++++++------ internal/state/optional_dependencies_test.go | 89 ++++++++++++--- 9 files changed, 227 insertions(+), 78 deletions(-) diff --git a/api/v1alpha1/serverless_helpers.go b/api/v1alpha1/serverless_helpers.go index 2edacd069..2318f0916 100644 --- a/api/v1alpha1/serverless_helpers.go +++ b/api/v1alpha1/serverless_helpers.go @@ -25,7 +25,7 @@ const ( DefaultEnableInternal = false DefaultRegistryAddress = "k3d-kyma-registry:5000" DefaultServerAddress = "k3d-kyma-registry:5000" - FeatureDisabled = "" + EndpointDisabled = "" DefaultEventingEndpoint = "http://eventing-publisher-proxy.kyma-system.svc.cluster.local/publish" ) diff --git a/api/v1alpha1/serverless_types.go b/api/v1alpha1/serverless_types.go index fb9176ba4..4c2f9e5de 100644 --- a/api/v1alpha1/serverless_types.go +++ b/api/v1alpha1/serverless_types.go @@ -32,9 +32,18 @@ type Endpoint struct { // ServerlessSpec defines the desired state of Serverless type ServerlessSpec struct { - Tracing *Endpoint `json:"tracing,omitempty"` - Eventing *Endpoint `json:"eventing,omitempty"` - DockerRegistry *DockerRegistry `json:"dockerRegistry,omitempty"` + Tracing *Endpoint `json:"tracing,omitempty"` + Eventing *Endpoint `json:"eventing,omitempty"` + DockerRegistry *DockerRegistry `json:"dockerRegistry,omitempty"` + TargetCPUUtilizationPercentage string `json:"targetCPUUtilizationPercentage,omitempty"` + FunctionRequeueDuration string `json:"functionRequeueDuration,omitempty"` + FunctionBuildExecutorArgs string `json:"functionBuildExecutorArgs,omitempty"` + FunctionBuildMaxSimultaneousJobs string `json:"functionBuildMaxSimultaneousJobs,omitempty"` + HealthzLivenessTimeout string `json:"healthzLivenessTimeout,omitempty"` + FunctionRequestBodyLimitMb string `json:"functionRequestBodyLimitMb,omitempty"` + FunctionTimeoutSec string `json:"functionTimeoutSec,omitempty"` + DefaultBuildJobPreset string `json:"defaultBuildJobPreset,omitempty"` + DefaultRuntimePodPreset string `json:"defaultRuntimePodPreset,omitempty"` } type State string @@ -83,6 +92,16 @@ type ServerlessStatus struct { EventingEndpoint string `json:"eventingEndpoint,omitempty"` TracingEndpoint string `json:"tracingEndpoint,omitempty"` + CPUUtilizationPercentage string `json:"targetCPUUtilizationPercentage,omitempty"` + RequeueDuration string `json:"functionRequeueDuration,omitempty"` + BuildExecutorArgs string `json:"functionBuildExecutorArgs,omitempty"` + BuildMaxSimultaneousJobs string `json:"functionBuildMaxSimultaneousJobs,omitempty"` + HealthzLivenessTimeout string `json:"healthzLivenessTimeout,omitempty"` + RequestBodyLimitMb string `json:"functionRequestBodyLimitMb,omitempty"` + TimeoutSec string `json:"functionTimeoutSec,omitempty"` + DefaultBuildJobPreset string `json:"defaultBuildJobPreset,omitempty"` + DefaultRuntimePodPreset string `json:"defaultRuntimePodPreset,omitempty"` + // Used registry configuration. // Contains registry URL or "internal" DockerRegistry string `json:"dockerRegistry,omitempty"` diff --git a/config/crd/bases/operator.kyma-project.io_serverlesses.yaml b/config/crd/bases/operator.kyma-project.io_serverlesses.yaml index 67ecdfb19..5868a59cf 100644 --- a/config/crd/bases/operator.kyma-project.io_serverlesses.yaml +++ b/config/crd/bases/operator.kyma-project.io_serverlesses.yaml @@ -51,6 +51,10 @@ spec: spec: description: ServerlessSpec defines the desired state of Serverless properties: + defaultBuildJobPreset: + type: string + defaultRuntimePodPreset: + type: string dockerRegistry: properties: enableInternal: @@ -65,6 +69,20 @@ spec: required: - endpoint type: object + functionBuildExecutorArgs: + type: string + functionBuildMaxSimultaneousJobs: + type: string + functionRequestBodyLimitMb: + type: string + functionRequeueDuration: + type: string + functionTimeoutSec: + type: string + healthzLivenessTimeout: + type: string + targetCPUUtilizationPercentage: + type: string tracing: properties: endpoint: @@ -144,6 +162,10 @@ spec: - type type: object type: array + defaultBuildJobPreset: + type: string + defaultRuntimePodPreset: + type: string dockerRegistry: description: Used registry configuration. Contains registry URL or "internal" @@ -151,6 +173,18 @@ spec: eventingEndpoint: description: Used the Eventing endpoint and the Tracing endpoint. type: string + functionBuildExecutorArgs: + type: string + functionBuildMaxSimultaneousJobs: + type: string + functionRequestBodyLimitMb: + type: string + functionRequeueDuration: + type: string + functionTimeoutSec: + type: string + healthzLivenessTimeout: + type: string served: description: Served signifies that current Serverless is managed. Value can be one of ("True", "False"). @@ -168,6 +202,8 @@ spec: - Error - Warning type: string + targetCPUUtilizationPercentage: + type: string tracingEndpoint: type: string required: diff --git a/controllers/serverless_controller_test.go b/controllers/serverless_controller_test.go index bd5ad3dc4..4d6f816c1 100644 --- a/controllers/serverless_controller_test.go +++ b/controllers/serverless_controller_test.go @@ -24,7 +24,7 @@ var _ = Describe("Serverless controller", func() { var ( serverlessDataDefault = serverlessData{ - TraceCollectorURL: pointer.String(v1alpha1.FeatureDisabled), + TraceCollectorURL: pointer.String(v1alpha1.EndpointDisabled), EnableInternal: pointer.Bool(v1alpha1.DefaultEnableInternal), registrySecretData: registrySecretData{ ServerAddress: pointer.String(v1alpha1.DefaultServerAddress), diff --git a/controllers/testhelper_test.go b/controllers/testhelper_test.go index 93f490c41..f936d6913 100644 --- a/controllers/testhelper_test.go +++ b/controllers/testhelper_test.go @@ -312,7 +312,7 @@ func (h *testHelper) createCheckOptionalDependenciesFunc(deploymentName string, eventProxyURL = *expected.EventPublisherProxyURL } - traceCollectorURL := v1alpha1.FeatureDisabled + traceCollectorURL := v1alpha1.EndpointDisabled if expected.TraceCollectorURL != nil { traceCollectorURL = *expected.TraceCollectorURL } diff --git a/internal/chart/flags.go b/internal/chart/flags.go index 251275e1f..1111a0277 100644 --- a/internal/chart/flags.go +++ b/internal/chart/flags.go @@ -1,6 +1,6 @@ package chart -func AppendContainersFlags(flags map[string]interface{}, publisherURL, traceCollectorURL string) map[string]interface{} { +func AppendContainersFlags(flags map[string]interface{}, publisherURL, traceCollectorURL, CPUUtilizationPercentage, requeueDuration, buildExecutorArgs, maxSimultaneousJobs, healthzLivenessTimeout, requestBodyLimitMb, timeoutSec, defaultBuildJobPreset, defaultRuntimePodPreset string) map[string]interface{} { flags["containers"] = map[string]interface{}{ "manager": map[string]interface{}{ "envs": map[string]interface{}{ @@ -10,6 +10,15 @@ func AppendContainersFlags(flags map[string]interface{}, publisherURL, traceColl "functionPublisherProxyAddress": map[string]interface{}{ "value": publisherURL, }, + "targetCPUUtilizationPercentage": getValueOrEmpty(CPUUtilizationPercentage), + "functionRequeueDuration": getValueOrEmpty(requeueDuration), + "functionBuildExecutorArgs": getValueOrEmpty(buildExecutorArgs), + "functionBuildMaxSimultaneousJobs": getValueOrEmpty(maxSimultaneousJobs), + "healthzLivenessTimeout": getValueOrEmpty(healthzLivenessTimeout), + "functionRequestBodyLimitMb": getValueOrEmpty(requestBodyLimitMb), + "functionTimeoutSec": getValueOrEmpty(timeoutSec), + "defaultBuildJobPreset": getValueOrEmpty(defaultBuildJobPreset), + "defaultRuntimePodPreset": getValueOrEmpty(defaultRuntimePodPreset), }, }, } @@ -17,6 +26,13 @@ func AppendContainersFlags(flags map[string]interface{}, publisherURL, traceColl return flags } +func getValueOrEmpty(value string) map[string]interface{} { + if value == "" { + return map[string]interface{}{} + } + return map[string]interface{}{"value": value} +} + /* AppendNodePortFlag nodePort must be int64, because when we compare old Flags with new flags, by default all integers are int64 diff --git a/internal/chart/flags_test.go b/internal/chart/flags_test.go index 96c982157..f9d61a8e8 100644 --- a/internal/chart/flags_test.go +++ b/internal/chart/flags_test.go @@ -61,27 +61,3 @@ func TestAppendExternalRegistryFlags(t *testing.T) { }, flags) }) } - -func TestAppendContainersFlags(t *testing.T) { - t.Run("append flags", func(t *testing.T) { - publisherURL := "test-proxy-url" - collectorURL := "test-trace-url" - - flags := AppendContainersFlags(map[string]interface{}{}, publisherURL, collectorURL) - - require.Equal(t, map[string]interface{}{ - "containers": map[string]interface{}{ - "manager": map[string]interface{}{ - "envs": map[string]interface{}{ - "functionTraceCollectorEndpoint": map[string]interface{}{ - "value": collectorURL, - }, - "functionPublisherProxyAddress": map[string]interface{}{ - "value": publisherURL, - }, - }, - }, - }, - }, flags) - }) -} diff --git a/internal/state/optional_dependencies.go b/internal/state/optional_dependencies.go index f42022697..2691a5968 100644 --- a/internal/state/optional_dependencies.go +++ b/internal/state/optional_dependencies.go @@ -3,16 +3,16 @@ package state import ( "context" "fmt" + "github.com/kyma-project/serverless-manager/api/v1alpha1" + "github.com/kyma-project/serverless-manager/internal/chart" "github.com/kyma-project/serverless-manager/internal/tracing" "github.com/pkg/errors" "go.uber.org/zap" - "sigs.k8s.io/controller-runtime/pkg/client" - - "github.com/kyma-project/serverless-manager/api/v1alpha1" - "github.com/kyma-project/serverless-manager/internal/chart" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" controllerruntime "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "strings" ) // enable or disable serverless optional dependencies based on the Serverless Spec and installed module on the cluster @@ -26,21 +26,22 @@ func sFnOptionalDependencies(ctx context.Context, r *reconciler, s *systemState) } eventingURL := getEventingURL(s.instance.Spec) - // update status and condition if status is not up-to-date - if s.instance.Status.EventingEndpoint != eventingURL || - s.instance.Status.TracingEndpoint != tracingURL || - !meta.IsStatusConditionPresentAndEqual(s.instance.Status.Conditions, string(v1alpha1.ConditionTypeConfigured), metav1.ConditionTrue) { - - s.instance.Status.EventingEndpoint = eventingURL - s.instance.Status.TracingEndpoint = tracingURL + if statusChanged, svlsCfgMsg := updateStatus(&s.instance, eventingURL, tracingURL); statusChanged { + s.setState(v1alpha1.StateProcessing) + s.instance.UpdateConditionTrue( + v1alpha1.ConditionTypeConfigured, + v1alpha1.ConditionReasonConfigured, + fmt.Sprintf(svlsCfgMsg), + ) + return nextState(sFnUpdateStatusAndRequeue) + } + if configurationStatusIsNotReady(s.instance.Status.Conditions) { s.setState(v1alpha1.StateProcessing) s.instance.UpdateConditionTrue( v1alpha1.ConditionTypeConfigured, v1alpha1.ConditionReasonConfigured, - fmt.Sprintf("Configured with %s Publisher Proxy URL and %s Trace Collector URL.", - dependencyState(s.instance.Status.EventingEndpoint), - dependencyState(s.instance.Status.TracingEndpoint)), + "Configuration ready", ) return nextState(sFnUpdateStatusAndRequeue) } @@ -49,16 +50,29 @@ func sFnOptionalDependencies(ctx context.Context, r *reconciler, s *systemState) s.chartConfig.Release.Flags, s.instance.Status.EventingEndpoint, s.instance.Status.TracingEndpoint, + s.instance.Status.CPUUtilizationPercentage, + s.instance.Status.RequeueDuration, + s.instance.Status.BuildExecutorArgs, + s.instance.Status.BuildMaxSimultaneousJobs, + s.instance.Status.HealthzLivenessTimeout, + s.instance.Status.RequestBodyLimitMb, + s.instance.Status.TimeoutSec, + s.instance.Status.DefaultBuildJobPreset, + s.instance.Status.DefaultRuntimePodPreset, ) return nextState(sFnApplyResources) } +func configurationStatusIsNotReady(conditions []metav1.Condition) bool { + if !meta.IsStatusConditionPresentAndEqual(conditions, string(v1alpha1.ConditionTypeConfigured), metav1.ConditionTrue) { + return true + } + return false +} + func getTracingURL(ctx context.Context, log *zap.SugaredLogger, client client.Client, spec v1alpha1.ServerlessSpec) (string, error) { if spec.Tracing != nil { - if spec.Tracing.Endpoint == "" { - return v1alpha1.FeatureDisabled, nil - } return spec.Tracing.Endpoint, nil } @@ -66,30 +80,59 @@ func getTracingURL(ctx context.Context, log *zap.SugaredLogger, client client.Cl if err != nil { return "", errors.Wrap(err, "while getting trace pipeline") } - if tracingURL == "" { - return v1alpha1.FeatureDisabled, nil - } return tracingURL, nil } func getEventingURL(spec v1alpha1.ServerlessSpec) string { if spec.Eventing != nil { - if spec.Eventing.Endpoint == "" { - return v1alpha1.FeatureDisabled - } return spec.Eventing.Endpoint } return v1alpha1.DefaultEventingEndpoint } -// returns "custom" or "no" based on args -func dependencyState(url string) string { - switch { - case url == "" || url == v1alpha1.FeatureDisabled: - return "no" - case url == v1alpha1.DefaultEventingEndpoint: - return "default" - default: - return "custom" +func updateStatus(instance *v1alpha1.Serverless, eventingURL, tracingURL string) (bool, string) { + spec := instance.Spec + status := instance.Status + + hasChanged := false + + fields := []struct { + specField string + statusField *string + cfgMsg string + }{ + {spec.TargetCPUUtilizationPercentage, &status.CPUUtilizationPercentage, "CPU utilization: %s"}, + {spec.FunctionRequeueDuration, &status.RequeueDuration, "function requeue duration: %s"}, + {spec.FunctionBuildExecutorArgs, &status.BuildExecutorArgs, "function build executor args: %s"}, + {spec.FunctionBuildMaxSimultaneousJobs, &status.BuildMaxSimultaneousJobs, "max number of simultaneous jobs: %s"}, + {spec.HealthzLivenessTimeout, &status.HealthzLivenessTimeout, "duration of health check: %s"}, + {spec.FunctionRequestBodyLimitMb, &status.RequestBodyLimitMb, "max size of request body: %s"}, + {spec.FunctionTimeoutSec, &status.TimeoutSec, "timeout: %s"}, + {spec.DefaultBuildJobPreset, &status.DefaultBuildJobPreset, "default build job preset: %s"}, + {spec.DefaultRuntimePodPreset, &status.DefaultRuntimePodPreset, "default runtime pod preset: %s"}, + {eventingURL, &status.EventingEndpoint, "eventing endpoint: %s"}, + {tracingURL, &status.TracingEndpoint, "tracing endpoint: %s"}, } + + sb := strings.Builder{} + sb.WriteString("Serverless configuration changes: ") + separator := false + + for _, field := range fields { + if field.specField != *field.statusField { + if separator { + sb.WriteString(", ") + } + *field.statusField = field.specField + sb.WriteString(fmt.Sprintf(field.cfgMsg, field.specField)) + separator = true + hasChanged = true + } + } + if !hasChanged { + sb.WriteString("no changes") + } + instance.Status = status + + return hasChanged, sb.String() } diff --git a/internal/state/optional_dependencies_test.go b/internal/state/optional_dependencies_test.go index 48318315c..ffa2c19e4 100644 --- a/internal/state/optional_dependencies_test.go +++ b/internal/state/optional_dependencies_test.go @@ -2,9 +2,12 @@ package state import ( "context" + "fmt" + "github.com/kyma-project/serverless-manager/internal/chart" "github.com/stretchr/testify/assert" "go.uber.org/zap" corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/utils/pointer" "sigs.k8s.io/controller-runtime/pkg/client" @@ -12,9 +15,19 @@ import ( "testing" "github.com/kyma-project/serverless-manager/api/v1alpha1" - "github.com/kyma-project/serverless-manager/internal/chart" "github.com/stretchr/testify/require" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +const ( + cpuUtilizationTest = "test-CPU-utilization-percentage" + requeueDurationTest = "test-requeue-duration" + executorArgsTest = "test-build-executor-args" + maxSimultaneousJobsTest = "test-max-simultaneous-jobs" + healthzLivenessTimeoutTest = "test-healthz-liveness-timeout" + requestBodyLimitMbTest = "test-request-body-limit-mb" + timeoutSecTest = "test-timeout-sec" + defaultBuildJobPresetTest = "test=default-build-job-preset" + defaultRuntimePodPresetTest = "test-default-runtime-pod-preset" ) func Test_sFnOptionalDependencies(t *testing.T) { @@ -23,10 +36,10 @@ func Test_sFnOptionalDependencies(t *testing.T) { tracingCollectorURL := "http://telemetry-otlp-traces.some-ns.svc.cluster.local:4318/v1/traces" customEventingURL := "eventing-url" - configuredMsg := "Configured with custom Publisher Proxy URL and custom Trace Collector URL." - noConfigurationMsg := "Configured with no Publisher Proxy URL and no Trace Collector URL." - traceConfiguredMsg := "Configured with no Publisher Proxy URL and custom Trace Collector URL." - defaultEventingConfigurationMsg := "Configured with default Publisher Proxy URL and no Trace Collector URL." + configuredMsg := "Serverless configuration changes: eventing endpoint: eventing-url, tracing endpoint: http://telemetry-otlp-traces.some-ns.svc.cluster.local:4318/v1/traces" + noConfigurationMsg := "Configuration ready" + traceConfiguredMsg := "Serverless configuration changes: tracing endpoint: http://telemetry-otlp-traces.some-ns.svc.cluster.local:4318/v1/traces" + defaultEventingConfigurationMsg := "Serverless configuration changes: eventing endpoint: http://eventing-publisher-proxy.kyma-system.svc.cluster.local/publish" testCases := map[string]struct { tracing *v1alpha1.Endpoint @@ -47,19 +60,19 @@ func Test_sFnOptionalDependencies(t *testing.T) { extraCR: []client.Object{fixTracingSvc()}, eventing: &v1alpha1.Endpoint{Endpoint: ""}, expectedTracingURL: tracingCollectorURL, - expectedEventingURL: v1alpha1.FeatureDisabled, + expectedEventingURL: v1alpha1.EndpointDisabled, expectedStatusMessage: traceConfiguredMsg, }, "Tracing is not set, TracePipeline svc is not available": { expectedEventingURL: v1alpha1.DefaultEventingEndpoint, - expectedTracingURL: v1alpha1.FeatureDisabled, + expectedTracingURL: v1alpha1.EndpointDisabled, expectedStatusMessage: defaultEventingConfigurationMsg, }, "Tracing and eventing is disabled": { tracing: &v1alpha1.Endpoint{Endpoint: ""}, eventing: &v1alpha1.Endpoint{Endpoint: ""}, - expectedEventingURL: v1alpha1.FeatureDisabled, - expectedTracingURL: v1alpha1.FeatureDisabled, + expectedEventingURL: v1alpha1.EndpointDisabled, + expectedTracingURL: v1alpha1.EndpointDisabled, expectedStatusMessage: noConfigurationMsg, }, } @@ -98,6 +111,52 @@ func Test_sFnOptionalDependencies(t *testing.T) { }) } + t.Run("update status additional configuration overrides", func(t *testing.T) { + s := &systemState{ + instance: v1alpha1.Serverless{ + Spec: v1alpha1.ServerlessSpec{ + TargetCPUUtilizationPercentage: cpuUtilizationTest, + FunctionRequeueDuration: requeueDurationTest, + FunctionBuildExecutorArgs: executorArgsTest, + FunctionBuildMaxSimultaneousJobs: maxSimultaneousJobsTest, + HealthzLivenessTimeout: healthzLivenessTimeoutTest, + FunctionRequestBodyLimitMb: requestBodyLimitMbTest, + FunctionTimeoutSec: timeoutSecTest, + DefaultBuildJobPreset: defaultBuildJobPresetTest, + DefaultRuntimePodPreset: defaultRuntimePodPresetTest, + }, + }, + } + + c := fake.NewClientBuilder().WithScheme(scheme).Build() + r := &reconciler{log: zap.NewNop().Sugar(), k8s: k8s{client: c}} + next, result, err := sFnOptionalDependencies(context.TODO(), r, s) + + expectedNext := sFnUpdateStatusAndRequeue + requireEqualFunc(t, expectedNext, next) + require.Nil(t, result) + require.Nil(t, err) + + status := s.instance.Status + require.Equal(t, cpuUtilizationTest, status.CPUUtilizationPercentage) + require.Equal(t, requeueDurationTest, status.RequeueDuration) + require.Equal(t, executorArgsTest, status.BuildExecutorArgs) + require.Equal(t, maxSimultaneousJobsTest, status.BuildMaxSimultaneousJobs) + require.Equal(t, healthzLivenessTimeoutTest, status.HealthzLivenessTimeout) + require.Equal(t, requestBodyLimitMbTest, status.RequestBodyLimitMb) + require.Equal(t, timeoutSecTest, status.TimeoutSec) + require.Equal(t, defaultBuildJobPresetTest, status.DefaultBuildJobPreset) + require.Equal(t, defaultRuntimePodPresetTest, status.DefaultRuntimePodPreset) + + require.Equal(t, v1alpha1.StateProcessing, status.State) + requireContainsCondition(t, status, + v1alpha1.ConditionTypeConfigured, + metav1.ConditionTrue, + v1alpha1.ConditionReasonConfigured, + fmt.Sprintf("Serverless configuration changes: CPU utilization: %s, function requeue duration: %s, function build executor args: %s, max number of simultaneous jobs: %s, duration of health check: %s, max size of request body: %s, timeout: %s, default build job preset: %s, default runtime pod preset: %s, eventing endpoint: http://eventing-publisher-proxy.kyma-system.svc.cluster.local/publish", cpuUtilizationTest, requeueDurationTest, executorArgsTest, maxSimultaneousJobsTest, healthzLivenessTimeoutTest, requestBodyLimitMbTest, timeoutSecTest, defaultBuildJobPresetTest, defaultRuntimePodPresetTest), + ) + }) + t.Run("reconcile from configurationError", func(t *testing.T) { s := &systemState{ instance: v1alpha1.Serverless{ @@ -116,11 +175,11 @@ func Test_sFnOptionalDependencies(t *testing.T) { }, State: v1alpha1.StateError, EventingEndpoint: "test-event-URL", - TracingEndpoint: v1alpha1.FeatureDisabled, + TracingEndpoint: v1alpha1.EndpointDisabled, }, Spec: v1alpha1.ServerlessSpec{ Eventing: &v1alpha1.Endpoint{Endpoint: "test-event-URL"}, - Tracing: &v1alpha1.Endpoint{Endpoint: v1alpha1.FeatureDisabled}, + Tracing: &v1alpha1.Endpoint{Endpoint: v1alpha1.EndpointDisabled}, DockerRegistry: &v1alpha1.DockerRegistry{ EnableInternal: pointer.Bool(false), SecretName: pointer.String("boo"), @@ -158,7 +217,7 @@ func Test_sFnOptionalDependencies(t *testing.T) { v1alpha1.ConditionTypeConfigured, metav1.ConditionTrue, v1alpha1.ConditionReasonConfigured, - "Configured with custom Publisher Proxy URL and no Trace Collector URL.") + "Configuration ready") require.Equal(t, v1alpha1.StateProcessing, s.instance.Status.State) }) @@ -184,8 +243,8 @@ func Test_sFnOptionalDependencies(t *testing.T) { }, } - client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(fixTracingSvc()).Build() - r := &reconciler{log: zap.NewNop().Sugar(), k8s: k8s{client: client}} + c := fake.NewClientBuilder().WithScheme(scheme).WithObjects(fixTracingSvc()).Build() + r := &reconciler{log: zap.NewNop().Sugar(), k8s: k8s{client: c}} _, _, err := sFnOptionalDependencies(context.Background(), r, s) require.NoError(t, err)