feat(api): add Pipe dependencies

squakez · squakez · commit 067dc3b3e501 · 2025-09-04T14:19:11.000+02:00
Add the possibility to add any dependency. Useful, for instance, for external JDBC driver
diff --git a/docs/modules/ROOT/partials/apis/camel-k-crds.adoc b/docs/modules/ROOT/partials/apis/camel-k-crds.adoc
@@ -4814,6 +4814,13 @@ string
 
 Custom SA to use for the Pipe
 
+|`dependencies` +
+[]string
+|
+
+
+the list of Camel or Maven dependencies required by the Pipe
+
 
 |===
 
diff --git a/e2e/common/traits/health_test.go b/e2e/common/traits/health_test.go
@@ -29,11 +29,10 @@ import (
 	"testing"
 	"time"
 
-	"github.com/onsi/gomega/gstruct"
-
 	camelv1 "github.com/apache/camel-k/v2/pkg/apis/camel/v1"
 
 	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/gstruct"
 
 	corev1 "k8s.io/api/core/v1"
 
@@ -44,6 +43,7 @@ import (
 func TestHealthTrait(t *testing.T) {
 	t.Parallel()
 	WithNewTestNamespace(t, func(ctx context.Context, g *WithT, ns string) {
+
 		t.Run("Readiness condition with stopped route scaled", func(t *testing.T) {
 			name := RandomizedSuffixName("java")
 			g.Expect(KamelRun(t, ctx, ns, "files/Java.java",
@@ -240,12 +240,13 @@ func TestHealthTrait(t *testing.T) {
 			g.Expect(CreateTimerKamelet(t, ctx, ns, source)()).To(Succeed())
 			g.Expect(CreateLogKamelet(t, ctx, ns, sink)()).To(Succeed())
 
-			g.Expect(KamelBind(t, ctx, ns, source, sink, "-p",
-				"source.message=Magicstring!", "-p", "sink.loggerName=binding",
-				"--trait", "health.enabled=true",
-				"--trait", "jolokia.enabled=true",
-				"--trait", "jolokia.use-ssl-client-authentication=false",
-				"--trait", "jolokia.protocol=http",
+			g.Expect(KamelBind(t, ctx, ns, source, sink,
+				"-p", "source.message=Magicstring!",
+				"-p", "sink.loggerName=binding",
+				"-t", "health.enabled=true",
+				"-t", "jvm.agents=jolokia;https://repo1.maven.org/maven2/org/jolokia/jolokia-agent-jvm/2.3.0/jolokia-agent-jvm-2.3.0-javaagent.jar;host=*",
+				"-t", "container.ports=jolokia;8778",
+				"-d", "camel:management",
 				"--name", name).Execute()).To(Succeed())
 
 			g.Eventually(IntegrationPodPhase(t, ctx, ns, name), TestTimeoutLong).Should(Equal(corev1.PodRunning))
@@ -470,5 +471,6 @@ func TestHealthTrait(t *testing.T) {
 				WithTransform(IntegrationConditionReason, Equal(v1.IntegrationConditionDeploymentReadyReason)),
 				WithTransform(IntegrationConditionMessage, Equal("1/1 ready replicas"))))
 		})
+
 	})
 }
diff --git a/helm/camel-k/crds/camel-k-crds.yaml b/helm/camel-k/crds/camel-k-crds.yaml
@@ -24110,6 +24110,12 @@ spec:
           spec:
             description: the specification of a Pipe
             properties:
+              dependencies:
+                description: the list of Camel or Maven dependencies required by the
+                  Pipe
+                items:
+                  type: string
+                type: array
               errorHandler:
                 description: ErrorHandler is an optional handler called upon an error
                   occurring in the integration
diff --git a/pkg/apis/camel/v1/pipe_types.go b/pkg/apis/camel/v1/pipe_types.go
@@ -60,6 +60,8 @@ type PipeSpec struct {
 	Replicas *int32 `json:"replicas,omitempty"`
 	// Custom SA to use for the Pipe
 	ServiceAccountName string `json:"serviceAccountName,omitempty"`
+	// the list of Camel or Maven dependencies required by the Pipe
+	Dependencies []string `json:"dependencies,omitempty"`
 }
 
 // Endpoint represents a source/sink external entity (could be any Kubernetes resource or Camel URI).
diff --git a/pkg/apis/camel/v1/zz_generated.deepcopy.go b/pkg/apis/camel/v1/zz_generated.deepcopy.go
diff --git a/pkg/client/camel/applyconfiguration/camel/v1/pipespec.go b/pkg/client/camel/applyconfiguration/camel/v1/pipespec.go
diff --git a/pkg/cmd/bind.go b/pkg/cmd/bind.go
@@ -65,6 +65,7 @@ func newCmdBind(rootCmdOptions *RootCmdOptions) (*cobra.Command, *bindCmdOptions
 	cmd.Flags().StringArray("annotation", nil, "Add an annotation to the Pipe. E.g. \"--annotation my.company=hello\"")
 	cmd.Flags().Bool("force", false, "Force creation of Pipe regardless of potential misconfiguration.")
 	cmd.Flags().String("service-account", "", "The SA to use to run this binding")
+	cmd.Flags().StringArrayP("dependency", "d", nil, `A dependency that should be included, e.g., "camel:mail" for a Camel component, "mvn:org.my:app:1.0" for a Maven dependency`)
 
 	return &cmd, &options
 }
@@ -89,6 +90,7 @@ type bindCmdOptions struct {
 	Annotations    []string `mapstructure:"annotations" yaml:",omitempty"`
 	Force          bool     `mapstructure:"force" yaml:",omitempty"`
 	ServiceAccount string   `mapstructure:"service-account" yaml:",omitempty"`
+	Dependencies   []string `mapstructure:"dependencies" yaml:",omitempty"`
 }
 
 func (o *bindCmdOptions) preRunE(cmd *cobra.Command, args []string) error {
@@ -194,7 +196,7 @@ func (o *bindCmdOptions) run(cmd *cobra.Command, args []string) error {
 
 	name := o.nameFor(source, sink)
 
-	binding := v1.Pipe{
+	pipe := v1.Pipe{
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: o.Namespace,
 			Name:      name,
@@ -205,61 +207,65 @@ func (o *bindCmdOptions) run(cmd *cobra.Command, args []string) error {
 		},
 	}
 
+	if o.Dependencies != nil {
+		pipe.Spec.Dependencies = o.Dependencies
+	}
+
 	if o.ErrorHandler != "" {
 		if errorHandler, err := o.parseErrorHandler(); err == nil {
-			binding.Spec.ErrorHandler = errorHandler
+			pipe.Spec.ErrorHandler = errorHandler
 		} else {
 			return err
 		}
 	}
 
 	if len(o.Steps) > 0 {
-		binding.Spec.Steps = make([]v1.Endpoint, 0)
+		pipe.Spec.Steps = make([]v1.Endpoint, 0)
 		for idx, stepDesc := range o.Steps {
 			stepIndex := idx + 1
 			stepKey := fmt.Sprintf("%s%d", stepKeyPrefix, stepIndex)
 			step, err := o.decode(stepDesc, stepKey)
 			if err != nil {
 				return err
 			}
-			binding.Spec.Steps = append(binding.Spec.Steps, step)
+			pipe.Spec.Steps = append(pipe.Spec.Steps, step)
 		}
 	}
 
 	if len(o.Traits) > 0 {
-		if binding.Annotations == nil {
-			binding.Annotations = make(map[string]string)
+		if pipe.Annotations == nil {
+			pipe.Annotations = make(map[string]string)
 		}
 
 		for _, t := range o.Traits {
 			kv := strings.SplitN(t, "=", 2)
 			if len(kv) != 2 {
 				return fmt.Errorf("could not parse trait configuration %s, expected format 'trait.property=value'", t)
 			}
-			value := maybeBuildArrayNotation(binding.Annotations[v1.TraitAnnotationPrefix+kv[0]], kv[1])
-			binding.Annotations[v1.TraitAnnotationPrefix+kv[0]] = value
+			value := maybeBuildArrayNotation(pipe.Annotations[v1.TraitAnnotationPrefix+kv[0]], kv[1])
+			pipe.Annotations[v1.TraitAnnotationPrefix+kv[0]] = value
 		}
 	}
 
 	if o.ServiceAccount != "" {
-		binding.Spec.ServiceAccountName = o.ServiceAccount
+		pipe.Spec.ServiceAccountName = o.ServiceAccount
 	}
 
 	// --operator-id={id} is a syntax sugar for '--annotation camel.apache.org/operator.id={id}'
-	binding.SetOperatorID(strings.TrimSpace(o.OperatorID))
+	pipe.SetOperatorID(strings.TrimSpace(o.OperatorID))
 
 	for _, annotation := range o.Annotations {
 		parts := strings.SplitN(annotation, "=", 2)
 		if len(parts) == 2 {
-			binding.Annotations[parts[0]] = parts[1]
+			pipe.Annotations[parts[0]] = parts[1]
 		}
 	}
 
 	if o.OutputFormat != "" {
-		return showPipeOutput(cmd, &binding, o.OutputFormat, client.GetScheme())
+		return showPipeOutput(cmd, &pipe, o.OutputFormat, client.GetScheme())
 	}
 
-	replaced, err := kubernetes.ReplaceResource(o.Context, client, &binding)
+	replaced, err := kubernetes.ReplaceResource(o.Context, client, &pipe)
 	if err != nil {
 		return err
 	}
diff --git a/pkg/cmd/bind_test.go b/pkg/cmd/bind_test.go
@@ -277,3 +277,28 @@ func TestBindOutputWithoutKubernetesCluster(t *testing.T) {
 	_, err = ExecuteCommand(bindCmd, cmdBind, "my:src", "my:dst", "-o", "yaml")
 	require.NoError(t, err)
 }
+
+func TestBindOutputWithDependencies(t *testing.T) {
+	buildCmdOptions, bindCmd, _ := initializeBindCmdOptions(t)
+	output, err := ExecuteCommand(bindCmd, cmdBind, "my:src", "my:dst", "-o", "yaml", "-d", "camel:my-comp", "-d", "mvn:my-dep")
+	assert.Equal(t, "yaml", buildCmdOptions.OutputFormat)
+
+	require.NoError(t, err)
+	assert.Equal(t, `apiVersion: camel.apache.org/v1
+kind: Pipe
+metadata:
+  annotations:
+    camel.apache.org/operator.id: camel-k
+  creationTimestamp: null
+  name: my-to-my
+spec:
+  dependencies:
+  - camel:my-comp
+  - mvn:my-dep
+  sink:
+    uri: my:dst
+  source:
+    uri: my:src
+status: {}
+`, output)
+}
diff --git a/pkg/cmd/run.go b/pkg/cmd/run.go
@@ -83,7 +83,7 @@ func newCmdRun(rootCmdOptions *RootCmdOptions) (*cobra.Command, *runCmdOptions)
 
 	cmd.Flags().String("name", "", "The integration name")
 	cmd.Flags().String("image", "", "An image built externally (ie, via CICD). Enabling it will skip the Integration build phase.")
-	cmd.Flags().StringArrayP("dependency", "d", nil, `A dependency that should be included, e.g., "-d camel:mail" for a Camel component, "-d mvn:org.my:app:1.0" for a Maven dependency`)
+	cmd.Flags().StringArrayP("dependency", "d", nil, `A dependency that should be included, e.g., "camel:mail" for a Camel component, "mvn:org.my:app:1.0" for a Maven dependency`)
 	cmd.Flags().BoolP("wait", "w", false, "Wait for the integration to be running")
 	cmd.Flags().StringP("kit", "k", "", "The kit used to run the integration")
 	cmd.Flags().StringArrayP("property", "p", nil, "Add a runtime property or a local properties file from a path "+
diff --git a/pkg/controller/pipe/initialize_test.go b/pkg/controller/pipe/initialize_test.go
@@ -185,6 +185,7 @@ func TestNewPipe(t *testing.T) {
 					Name:       "my-sink",
 				},
 			},
+			Dependencies: []string{"camel:management", "mvn:org.acme:jdbc-driver:1.0.0"},
 		},
 	}
 	c, err := internal.NewFakeClient(pipe, &source, &sink)
@@ -204,6 +205,8 @@ func TestNewPipe(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, pipe.Name, expectedIT.Name)
 	assert.Equal(t, v1.IntegrationPhaseNone, expectedIT.Status.Phase)
+	assert.Contains(t, expectedIT.Spec.Dependencies, "camel:management")
+	assert.Contains(t, expectedIT.Spec.Dependencies, "mvn:org.acme:jdbc-driver:1.0.0")
 	assert.Equal(t, "Pipe", expectedIT.Labels[kubernetes.CamelCreatorLabelKind])
 	assert.Equal(t, "my-pipe", expectedIT.Labels[kubernetes.CamelCreatorLabelName])
 	flow, err := json.Marshal(expectedIT.Spec.Flows[0].RawMessage)
diff --git a/pkg/controller/pipe/integration.go b/pkg/controller/pipe/integration.go
@@ -44,10 +44,10 @@ var (
 )
 
 // CreateIntegrationFor creates and Integration from a Pipe.
-func CreateIntegrationFor(ctx context.Context, c client.Client, binding *v1.Pipe) (*v1.Integration, error) {
+func CreateIntegrationFor(ctx context.Context, c client.Client, pipe *v1.Pipe) (*v1.Integration, error) {
 	controller := true
 	blockOwnerDeletion := true
-	annotations := util.CopyMap(binding.Annotations)
+	annotations := util.CopyMap(pipe.Annotations)
 	// avoid propagating the icon to the integration as it's heavyweight and not needed
 	delete(annotations, v1.AnnotationIcon)
 	traits, err := extractAndDeleteTraits(c, annotations)
@@ -57,16 +57,16 @@ func CreateIntegrationFor(ctx context.Context, c client.Client, binding *v1.Pipe
 
 	it := v1.Integration{
 		ObjectMeta: metav1.ObjectMeta{
-			Namespace:   binding.Namespace,
-			Name:        binding.Name,
+			Namespace:   pipe.Namespace,
+			Name:        pipe.Name,
 			Annotations: annotations,
-			Labels:      util.CopyMap(binding.Labels),
+			Labels:      util.CopyMap(pipe.Labels),
 			OwnerReferences: []metav1.OwnerReference{
 				{
-					APIVersion:         binding.APIVersion,
-					Kind:               binding.Kind,
-					Name:               binding.Name,
-					UID:                binding.UID,
+					APIVersion:         pipe.APIVersion,
+					Kind:               pipe.Kind,
+					Name:               pipe.Name,
+					UID:                pipe.UID,
 					Controller:         &controller,
 					BlockOwnerDeletion: &blockOwnerDeletion,
 				},
@@ -78,27 +78,31 @@ func CreateIntegrationFor(ctx context.Context, c client.Client, binding *v1.Pipe
 	if it.GetLabels() == nil {
 		it.SetLabels(make(map[string]string))
 	}
-	it.GetLabels()[kubernetes.CamelCreatorLabelKind] = binding.Kind
-	it.GetLabels()[kubernetes.CamelCreatorLabelName] = binding.Name
+	it.GetLabels()[kubernetes.CamelCreatorLabelKind] = pipe.Kind
+	it.GetLabels()[kubernetes.CamelCreatorLabelName] = pipe.Name
 
 	if traits != nil {
 		it.Spec.Traits = *traits
 	}
 
+	if pipe.Spec.Dependencies != nil {
+		it.Spec.Dependencies = pipe.Spec.Dependencies
+	}
+
 	// Set replicas (or override podspecable value) if present
-	if binding.Spec.Replicas != nil {
-		replicas := *binding.Spec.Replicas
+	if pipe.Spec.Replicas != nil {
+		replicas := *pipe.Spec.Replicas
 		it.Spec.Replicas = &replicas
 	}
 
-	profile, err := determineTraitProfile(ctx, c, binding)
+	profile, err := determineTraitProfile(ctx, c, pipe)
 	if err != nil {
 		return nil, err
 	}
 	it.Spec.Profile = profile
 
-	if binding.Spec.ServiceAccountName != "" {
-		it.Spec.ServiceAccountName = binding.Spec.ServiceAccountName
+	if pipe.Spec.ServiceAccountName != "" {
+		it.Spec.ServiceAccountName = pipe.Spec.ServiceAccountName
 	}
 
 	bindingContext := bindings.BindingContext{
@@ -109,22 +113,22 @@ func CreateIntegrationFor(ctx context.Context, c client.Client, binding *v1.Pipe
 		Metadata:  it.Annotations,
 	}
 
-	from, err := bindings.Translate(bindingContext, endpointTypeSourceContext, binding.Spec.Source)
+	from, err := bindings.Translate(bindingContext, endpointTypeSourceContext, pipe.Spec.Source)
 	if err != nil {
 		return nil, err
 	}
-	to, err := bindings.Translate(bindingContext, endpointTypeSinkContext, binding.Spec.Sink)
+	to, err := bindings.Translate(bindingContext, endpointTypeSinkContext, pipe.Spec.Sink)
 	if err != nil {
 		return nil, err
 	}
 	// error handler is optional
-	errorHandler, err := maybeErrorHandler(binding.Spec.ErrorHandler, bindingContext)
+	errorHandler, err := maybeErrorHandler(pipe.Spec.ErrorHandler, bindingContext)
 	if err != nil {
 		return nil, err
 	}
 
-	steps := make([]*bindings.Binding, 0, len(binding.Spec.Steps))
-	for idx, step := range binding.Spec.Steps {
+	steps := make([]*bindings.Binding, 0, len(pipe.Spec.Steps))
+	for idx, step := range pipe.Spec.Steps {
 		position := idx
 		stepBinding, err := bindings.Translate(bindingContext, bindings.EndpointContext{
 			Type:     v1.EndpointTypeAction,
diff --git a/pkg/controller/pipe/monitor.go b/pkg/controller/pipe/monitor.go
@@ -44,10 +44,10 @@ func (action *monitorAction) Name() string {
 	return "monitor"
 }
 
-func (action *monitorAction) CanHandle(binding *v1.Pipe) bool {
-	return binding.Status.Phase == v1.PipePhaseCreating ||
-		binding.Status.Phase == v1.PipePhaseError ||
-		binding.Status.Phase == v1.PipePhaseReady
+func (action *monitorAction) CanHandle(pipe *v1.Pipe) bool {
+	return pipe.Status.Phase == v1.PipePhaseCreating ||
+		pipe.Status.Phase == v1.PipePhaseError ||
+		pipe.Status.Phase == v1.PipePhaseReady
 }
 
 func (action *monitorAction) Handle(ctx context.Context, pipe *v1.Pipe) (*v1.Pipe, error) {
diff --git a/pkg/resources/config/crd/bases/camel.apache.org_pipes.yaml b/pkg/resources/config/crd/bases/camel.apache.org_pipes.yaml

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,8 @@ type PipeSpec struct {`
`60`	`60`	Replicas *int32 `json:"replicas,omitempty"`
`61`	`61`	`// Custom SA to use for the Pipe`
`62`	`62`	ServiceAccountName string `json:"serviceAccountName,omitempty"`
	`63`	`+ // the list of Camel or Maven dependencies required by the Pipe`
	`64`	+ Dependencies []string `json:"dependencies,omitempty"`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`// Endpoint represents a source/sink external entity (could be any Kubernetes resource or Camel URI).`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,7 @@ func newCmdBind(rootCmdOptions RootCmdOptions) (cobra.Command, *bindCmdOptions`
`65`	`65`	`cmd.Flags().StringArray("annotation", nil, "Add an annotation to the Pipe. E.g. \"--annotation my.company=hello\"")`
`66`	`66`	`cmd.Flags().Bool("force", false, "Force creation of Pipe regardless of potential misconfiguration.")`
`67`	`67`	`cmd.Flags().String("service-account", "", "The SA to use to run this binding")`
	`68`	+ cmd.Flags().StringArrayP("dependency", "d", nil, `A dependency that should be included, e.g., "camel:mail" for a Camel component, "mvn:org.my:app:1.0" for a Maven dependency`)
`68`	`69`
`69`	`70`	`return &cmd, &options`
`70`	`71`	`}`
`@@ -89,6 +90,7 @@ type bindCmdOptions struct {`
`89`	`90`	Annotations []string `mapstructure:"annotations" yaml:",omitempty"`
`90`	`91`	Force bool `mapstructure:"force" yaml:",omitempty"`
`91`	`92`	ServiceAccount string `mapstructure:"service-account" yaml:",omitempty"`
	`93`	+ Dependencies []string `mapstructure:"dependencies" yaml:",omitempty"`
`92`	`94`	`}`
`93`	`95`
`94`	`96`	`func (o bindCmdOptions) preRunE(cmd cobra.Command, args []string) error {`
`@@ -194,7 +196,7 @@ func (o bindCmdOptions) run(cmd cobra.Command, args []string) error {`
`194`	`196`
`195`	`197`	`name := o.nameFor(source, sink)`
`196`	`198`
`197`		`- binding := v1.Pipe{`
	`199`	`+ pipe := v1.Pipe{`
`198`	`200`	`ObjectMeta: metav1.ObjectMeta{`
`199`	`201`	`Namespace: o.Namespace,`
`200`	`202`	`Name: name,`
`@@ -205,61 +207,65 @@ func (o bindCmdOptions) run(cmd cobra.Command, args []string) error {`
`205`	`207`	`},`
`206`	`208`	`}`
`207`	`209`
	`210`	`+ if o.Dependencies != nil {`
	`211`	`+ pipe.Spec.Dependencies = o.Dependencies`
	`212`	`+ }`
	`213`	`+`
`208`	`214`	`if o.ErrorHandler != "" {`
`209`	`215`	`if errorHandler, err := o.parseErrorHandler(); err == nil {`
`210`		`- binding.Spec.ErrorHandler = errorHandler`
	`216`	`+ pipe.Spec.ErrorHandler = errorHandler`
`211`	`217`	`} else {`
`212`	`218`	`return err`
`213`	`219`	`}`
`214`	`220`	`}`
`215`	`221`
`216`	`222`	`if len(o.Steps) > 0 {`
`217`		`- binding.Spec.Steps = make([]v1.Endpoint, 0)`
	`223`	`+ pipe.Spec.Steps = make([]v1.Endpoint, 0)`
`218`	`224`	`for idx, stepDesc := range o.Steps {`
`219`	`225`	`stepIndex := idx + 1`
`220`	`226`	`stepKey := fmt.Sprintf("%s%d", stepKeyPrefix, stepIndex)`
`221`	`227`	`step, err := o.decode(stepDesc, stepKey)`
`222`	`228`	`if err != nil {`
`223`	`229`	`return err`
`224`	`230`	`}`
`225`		`- binding.Spec.Steps = append(binding.Spec.Steps, step)`
	`231`	`+ pipe.Spec.Steps = append(pipe.Spec.Steps, step)`
`226`	`232`	`}`
`227`	`233`	`}`
`228`	`234`
`229`	`235`	`if len(o.Traits) > 0 {`
`230`		`- if binding.Annotations == nil {`
`231`		`- binding.Annotations = make(map[string]string)`
	`236`	`+ if pipe.Annotations == nil {`
	`237`	`+ pipe.Annotations = make(map[string]string)`
`232`	`238`	`}`
`233`	`239`
`234`	`240`	`for _, t := range o.Traits {`
`235`	`241`	`kv := strings.SplitN(t, "=", 2)`
`236`	`242`	`if len(kv) != 2 {`
`237`	`243`	`return fmt.Errorf("could not parse trait configuration %s, expected format 'trait.property=value'", t)`
`238`	`244`	`}`
`239`		`- value := maybeBuildArrayNotation(binding.Annotations[v1.TraitAnnotationPrefix+kv[0]], kv[1])`
`240`		`- binding.Annotations[v1.TraitAnnotationPrefix+kv[0]] = value`
	`245`	`+ value := maybeBuildArrayNotation(pipe.Annotations[v1.TraitAnnotationPrefix+kv[0]], kv[1])`
	`246`	`+ pipe.Annotations[v1.TraitAnnotationPrefix+kv[0]] = value`
`241`	`247`	`}`
`242`	`248`	`}`
`243`	`249`
`244`	`250`	`if o.ServiceAccount != "" {`
`245`		`- binding.Spec.ServiceAccountName = o.ServiceAccount`
	`251`	`+ pipe.Spec.ServiceAccountName = o.ServiceAccount`
`246`	`252`	`}`
`247`	`253`
`248`	`254`	`// --operator-id={id} is a syntax sugar for '--annotation camel.apache.org/operator.id={id}'`
`249`		`- binding.SetOperatorID(strings.TrimSpace(o.OperatorID))`
	`255`	`+ pipe.SetOperatorID(strings.TrimSpace(o.OperatorID))`
`250`	`256`
`251`	`257`	`for _, annotation := range o.Annotations {`
`252`	`258`	`parts := strings.SplitN(annotation, "=", 2)`
`253`	`259`	`if len(parts) == 2 {`
`254`		`- binding.Annotations[parts[0]] = parts[1]`
	`260`	`+ pipe.Annotations[parts[0]] = parts[1]`
`255`	`261`	`}`
`256`	`262`	`}`
`257`	`263`
`258`	`264`	`if o.OutputFormat != "" {`
`259`		`- return showPipeOutput(cmd, &binding, o.OutputFormat, client.GetScheme())`
	`265`	`+ return showPipeOutput(cmd, &pipe, o.OutputFormat, client.GetScheme())`
`260`	`266`	`}`
`261`	`267`
`262`		`- replaced, err := kubernetes.ReplaceResource(o.Context, client, &binding)`
	`268`	`+ replaced, err := kubernetes.ReplaceResource(o.Context, client, &pipe)`
`263`	`269`	`if err != nil {`
`264`	`270`	`return err`
`265`	`271`	`}`