From a70d0c59768f402fbf13b9c35d5194d0824ea6ee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 18 Oct 2024 09:36:06 +0000
Subject: [PATCH 1/2] go.mod: bump go.uber.org/mock from 0.4.0 to 0.5.0

Bumps [go.uber.org/mock](https://github.com/uber/mock) from 0.4.0 to 0.5.0.
- [Release notes](https://github.com/uber/mock/releases)
- [Changelog](https://github.com/uber-go/mock/blob/main/CHANGELOG.md)
- [Commits](https://github.com/uber/mock/compare/v0.4.0...v0.5.0)

---
updated-dependencies:
- dependency-name: go.uber.org/mock
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod | 2 +-
 go.sum | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/go.mod b/go.mod
index 259f960ee..fc97f1825 100644
--- a/go.mod
+++ b/go.mod
@@ -44,7 +44,7 @@ require (
 	github.com/tetratelabs/wazero v1.8.1
 	github.com/twmb/franz-go/pkg/sr v1.2.0
 	github.com/twmb/go-cache v1.2.1
-	go.uber.org/mock v0.4.0
+	go.uber.org/mock v0.5.0
 	golang.org/x/exp v0.0.0-20241004190924-225e2abe05e6
 	golang.org/x/tools v0.26.0
 	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028
diff --git a/go.sum b/go.sum
index bf169f5e5..a1055bcdc 100644
--- a/go.sum
+++ b/go.sum
@@ -959,8 +959,8 @@ go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
 go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
-go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
+go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
+go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=

From ec87d87d1444f5d3d53ba7380d4ac73e94d37bfb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lovro=20Ma=C5=BEgon?= <lovro.mazgon@gmail.com>
Date: Fri, 18 Oct 2024 17:05:53 +0200
Subject: [PATCH 2/2] make generate

---
 pkg/lifecycle/stream/mock/destination.go      |   1 +
 pkg/lifecycle/stream/mock/dlq.go              |   1 +
 pkg/lifecycle/stream/mock/processor.go        |   9 +-
 pkg/lifecycle/stream/mock/source.go           |   1 +
 pkg/orchestrator/mock/orchestrator.go         | 298 +++++++++---------
 pkg/plugin/connector/mock/plugin.go           |   4 +
 .../builtin/impl/avro/mock_decoder.go         |   1 +
 .../builtin/impl/avro/mock_encoder.go         |   1 +
 pkg/plugin/processor/mock/processor.go        |   1 +
 pkg/plugin/processor/mock/registry.go         |   2 +
 pkg/processor/mock/plugin_service.go          |   9 +-
 pkg/provisioning/mock/provisioning.go         | 233 +++++++-------
 pkg/web/api/mock/connector.go                 |  57 ++--
 pkg/web/api/mock/connector_plugin.go          |   9 +-
 pkg/web/api/mock/connector_service.go         |  21 +-
 pkg/web/api/mock/pipeline.go                  |  65 ++--
 pkg/web/api/mock/processor.go                 |  57 ++--
 pkg/web/api/mock/processor_plugin.go          |   9 +-
 pkg/web/api/mock/processor_service_in.go      |  21 +-
 pkg/web/api/mock/processor_service_out.go     |  21 +-
 20 files changed, 427 insertions(+), 394 deletions(-)

diff --git a/pkg/lifecycle/stream/mock/destination.go b/pkg/lifecycle/stream/mock/destination.go
index ff75a9a58..a5d39db28 100644
--- a/pkg/lifecycle/stream/mock/destination.go
+++ b/pkg/lifecycle/stream/mock/destination.go
@@ -22,6 +22,7 @@ import (
 type Destination struct {
 	ctrl     *gomock.Controller
 	recorder *DestinationMockRecorder
+	isgomock struct{}
 }
 
 // DestinationMockRecorder is the mock recorder for Destination.
diff --git a/pkg/lifecycle/stream/mock/dlq.go b/pkg/lifecycle/stream/mock/dlq.go
index fc753be11..ce1df4708 100644
--- a/pkg/lifecycle/stream/mock/dlq.go
+++ b/pkg/lifecycle/stream/mock/dlq.go
@@ -21,6 +21,7 @@ import (
 type DLQHandler struct {
 	ctrl     *gomock.Controller
 	recorder *DLQHandlerMockRecorder
+	isgomock struct{}
 }
 
 // DLQHandlerMockRecorder is the mock recorder for DLQHandler.
diff --git a/pkg/lifecycle/stream/mock/processor.go b/pkg/lifecycle/stream/mock/processor.go
index 8f2a64e04..4ccffa4ca 100644
--- a/pkg/lifecycle/stream/mock/processor.go
+++ b/pkg/lifecycle/stream/mock/processor.go
@@ -22,6 +22,7 @@ import (
 type Processor struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorMockRecorder is the mock recorder for Processor.
@@ -42,17 +43,17 @@ func (m *Processor) EXPECT() *ProcessorMockRecorder {
 }
 
 // Open mocks base method.
-func (m *Processor) Open(arg0 context.Context) error {
+func (m *Processor) Open(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Open", arg0)
+	ret := m.ctrl.Call(m, "Open", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Open indicates an expected call of Open.
-func (mr *ProcessorMockRecorder) Open(arg0 any) *ProcessorOpenCall {
+func (mr *ProcessorMockRecorder) Open(ctx any) *ProcessorOpenCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*Processor)(nil).Open), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*Processor)(nil).Open), ctx)
 	return &ProcessorOpenCall{Call: call}
 }
 
diff --git a/pkg/lifecycle/stream/mock/source.go b/pkg/lifecycle/stream/mock/source.go
index c339f901f..57155e2d3 100644
--- a/pkg/lifecycle/stream/mock/source.go
+++ b/pkg/lifecycle/stream/mock/source.go
@@ -21,6 +21,7 @@ import (
 type Source struct {
 	ctrl     *gomock.Controller
 	recorder *SourceMockRecorder
+	isgomock struct{}
 }
 
 // SourceMockRecorder is the mock recorder for Source.
diff --git a/pkg/orchestrator/mock/orchestrator.go b/pkg/orchestrator/mock/orchestrator.go
index 78d6f71a5..15a4b552f 100644
--- a/pkg/orchestrator/mock/orchestrator.go
+++ b/pkg/orchestrator/mock/orchestrator.go
@@ -27,6 +27,7 @@ import (
 type PipelineService struct {
 	ctrl     *gomock.Controller
 	recorder *PipelineServiceMockRecorder
+	isgomock struct{}
 }
 
 // PipelineServiceMockRecorder is the mock recorder for PipelineService.
@@ -47,18 +48,18 @@ func (m *PipelineService) EXPECT() *PipelineServiceMockRecorder {
 }
 
 // AddConnector mocks base method.
-func (m *PipelineService) AddConnector(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) AddConnector(ctx context.Context, pipelineID, connectorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddConnector", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddConnector", ctx, pipelineID, connectorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddConnector indicates an expected call of AddConnector.
-func (mr *PipelineServiceMockRecorder) AddConnector(arg0, arg1, arg2 any) *PipelineServiceAddConnectorCall {
+func (mr *PipelineServiceMockRecorder) AddConnector(ctx, pipelineID, connectorID any) *PipelineServiceAddConnectorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnector", reflect.TypeOf((*PipelineService)(nil).AddConnector), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnector", reflect.TypeOf((*PipelineService)(nil).AddConnector), ctx, pipelineID, connectorID)
 	return &PipelineServiceAddConnectorCall{Call: call}
 }
 
@@ -86,18 +87,18 @@ func (c *PipelineServiceAddConnectorCall) DoAndReturn(f func(context.Context, st
 }
 
 // AddProcessor mocks base method.
-func (m *PipelineService) AddProcessor(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) AddProcessor(ctx context.Context, pipelineID, processorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddProcessor", ctx, pipelineID, processorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddProcessor indicates an expected call of AddProcessor.
-func (mr *PipelineServiceMockRecorder) AddProcessor(arg0, arg1, arg2 any) *PipelineServiceAddProcessorCall {
+func (mr *PipelineServiceMockRecorder) AddProcessor(ctx, pipelineID, processorID any) *PipelineServiceAddProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*PipelineService)(nil).AddProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*PipelineService)(nil).AddProcessor), ctx, pipelineID, processorID)
 	return &PipelineServiceAddProcessorCall{Call: call}
 }
 
@@ -125,18 +126,18 @@ func (c *PipelineServiceAddProcessorCall) DoAndReturn(f func(context.Context, st
 }
 
 // Create mocks base method.
-func (m *PipelineService) Create(arg0 context.Context, arg1 string, arg2 pipeline.Config, arg3 pipeline.ProvisionType) (*pipeline.Instance, error) {
+func (m *PipelineService) Create(ctx context.Context, id string, cfg pipeline.Config, p pipeline.ProvisionType) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Create", ctx, id, cfg, p)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *PipelineServiceMockRecorder) Create(arg0, arg1, arg2, arg3 any) *PipelineServiceCreateCall {
+func (mr *PipelineServiceMockRecorder) Create(ctx, id, cfg, p any) *PipelineServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineService)(nil).Create), arg0, arg1, arg2, arg3)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineService)(nil).Create), ctx, id, cfg, p)
 	return &PipelineServiceCreateCall{Call: call}
 }
 
@@ -164,17 +165,17 @@ func (c *PipelineServiceCreateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Delete mocks base method.
-func (m *PipelineService) Delete(arg0 context.Context, arg1 string) error {
+func (m *PipelineService) Delete(ctx context.Context, pipelineID string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, pipelineID)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *PipelineServiceMockRecorder) Delete(arg0, arg1 any) *PipelineServiceDeleteCall {
+func (mr *PipelineServiceMockRecorder) Delete(ctx, pipelineID any) *PipelineServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineService)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineService)(nil).Delete), ctx, pipelineID)
 	return &PipelineServiceDeleteCall{Call: call}
 }
 
@@ -202,18 +203,18 @@ func (c *PipelineServiceDeleteCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Get mocks base method.
-func (m *PipelineService) Get(arg0 context.Context, arg1 string) (*pipeline.Instance, error) {
+func (m *PipelineService) Get(ctx context.Context, id string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *PipelineServiceMockRecorder) Get(arg0, arg1 any) *PipelineServiceGetCall {
+func (mr *PipelineServiceMockRecorder) Get(ctx, id any) *PipelineServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineService)(nil).Get), ctx, id)
 	return &PipelineServiceGetCall{Call: call}
 }
 
@@ -241,17 +242,17 @@ func (c *PipelineServiceGetCall) DoAndReturn(f func(context.Context, string) (*p
 }
 
 // List mocks base method.
-func (m *PipelineService) List(arg0 context.Context) map[string]*pipeline.Instance {
+func (m *PipelineService) List(ctx context.Context) map[string]*pipeline.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*pipeline.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *PipelineServiceMockRecorder) List(arg0 any) *PipelineServiceListCall {
+func (mr *PipelineServiceMockRecorder) List(ctx any) *PipelineServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineService)(nil).List), ctx)
 	return &PipelineServiceListCall{Call: call}
 }
 
@@ -279,18 +280,18 @@ func (c *PipelineServiceListCall) DoAndReturn(f func(context.Context) map[string
 }
 
 // RemoveConnector mocks base method.
-func (m *PipelineService) RemoveConnector(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) RemoveConnector(ctx context.Context, pipelineID, connectorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveConnector", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveConnector", ctx, pipelineID, connectorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveConnector indicates an expected call of RemoveConnector.
-func (mr *PipelineServiceMockRecorder) RemoveConnector(arg0, arg1, arg2 any) *PipelineServiceRemoveConnectorCall {
+func (mr *PipelineServiceMockRecorder) RemoveConnector(ctx, pipelineID, connectorID any) *PipelineServiceRemoveConnectorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveConnector", reflect.TypeOf((*PipelineService)(nil).RemoveConnector), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveConnector", reflect.TypeOf((*PipelineService)(nil).RemoveConnector), ctx, pipelineID, connectorID)
 	return &PipelineServiceRemoveConnectorCall{Call: call}
 }
 
@@ -318,18 +319,18 @@ func (c *PipelineServiceRemoveConnectorCall) DoAndReturn(f func(context.Context,
 }
 
 // RemoveProcessor mocks base method.
-func (m *PipelineService) RemoveProcessor(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) RemoveProcessor(ctx context.Context, pipelineID, processorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveProcessor", ctx, pipelineID, processorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveProcessor indicates an expected call of RemoveProcessor.
-func (mr *PipelineServiceMockRecorder) RemoveProcessor(arg0, arg1, arg2 any) *PipelineServiceRemoveProcessorCall {
+func (mr *PipelineServiceMockRecorder) RemoveProcessor(ctx, pipelineID, processorID any) *PipelineServiceRemoveProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*PipelineService)(nil).RemoveProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*PipelineService)(nil).RemoveProcessor), ctx, pipelineID, processorID)
 	return &PipelineServiceRemoveProcessorCall{Call: call}
 }
 
@@ -357,18 +358,18 @@ func (c *PipelineServiceRemoveProcessorCall) DoAndReturn(f func(context.Context,
 }
 
 // Update mocks base method.
-func (m *PipelineService) Update(arg0 context.Context, arg1 string, arg2 pipeline.Config) (*pipeline.Instance, error) {
+func (m *PipelineService) Update(ctx context.Context, pipelineID string, cfg pipeline.Config) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, pipelineID, cfg)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *PipelineServiceMockRecorder) Update(arg0, arg1, arg2 any) *PipelineServiceUpdateCall {
+func (mr *PipelineServiceMockRecorder) Update(ctx, pipelineID, cfg any) *PipelineServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineService)(nil).Update), ctx, pipelineID, cfg)
 	return &PipelineServiceUpdateCall{Call: call}
 }
 
@@ -396,18 +397,18 @@ func (c *PipelineServiceUpdateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // UpdateDLQ mocks base method.
-func (m *PipelineService) UpdateDLQ(arg0 context.Context, arg1 string, arg2 pipeline.DLQ) (*pipeline.Instance, error) {
+func (m *PipelineService) UpdateDLQ(ctx context.Context, id string, dlq pipeline.DLQ) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateDLQ", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "UpdateDLQ", ctx, id, dlq)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UpdateDLQ indicates an expected call of UpdateDLQ.
-func (mr *PipelineServiceMockRecorder) UpdateDLQ(arg0, arg1, arg2 any) *PipelineServiceUpdateDLQCall {
+func (mr *PipelineServiceMockRecorder) UpdateDLQ(ctx, id, dlq any) *PipelineServiceUpdateDLQCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineService)(nil).UpdateDLQ), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineService)(nil).UpdateDLQ), ctx, id, dlq)
 	return &PipelineServiceUpdateDLQCall{Call: call}
 }
 
@@ -438,6 +439,7 @@ func (c *PipelineServiceUpdateDLQCall) DoAndReturn(f func(context.Context, strin
 type ConnectorService struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorServiceMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorServiceMockRecorder is the mock recorder for ConnectorService.
@@ -458,18 +460,18 @@ func (m *ConnectorService) EXPECT() *ConnectorServiceMockRecorder {
 }
 
 // AddProcessor mocks base method.
-func (m *ConnectorService) AddProcessor(arg0 context.Context, arg1, arg2 string) (*connector.Instance, error) {
+func (m *ConnectorService) AddProcessor(ctx context.Context, connectorID, processorID string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddProcessor", ctx, connectorID, processorID)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddProcessor indicates an expected call of AddProcessor.
-func (mr *ConnectorServiceMockRecorder) AddProcessor(arg0, arg1, arg2 any) *ConnectorServiceAddProcessorCall {
+func (mr *ConnectorServiceMockRecorder) AddProcessor(ctx, connectorID, processorID any) *ConnectorServiceAddProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*ConnectorService)(nil).AddProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*ConnectorService)(nil).AddProcessor), ctx, connectorID, processorID)
 	return &ConnectorServiceAddProcessorCall{Call: call}
 }
 
@@ -497,18 +499,18 @@ func (c *ConnectorServiceAddProcessorCall) DoAndReturn(f func(context.Context, s
 }
 
 // Create mocks base method.
-func (m *ConnectorService) Create(arg0 context.Context, arg1 string, arg2 connector.Type, arg3, arg4 string, arg5 connector.Config, arg6 connector.ProvisionType) (*connector.Instance, error) {
+func (m *ConnectorService) Create(ctx context.Context, id string, t connector.Type, plugin, pipelineID string, c connector.Config, p connector.ProvisionType) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret := m.ctrl.Call(m, "Create", ctx, id, t, plugin, pipelineID, c, p)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ConnectorServiceMockRecorder) Create(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *ConnectorServiceCreateCall {
+func (mr *ConnectorServiceMockRecorder) Create(ctx, id, t, plugin, pipelineID, c, p any) *ConnectorServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorService)(nil).Create), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorService)(nil).Create), ctx, id, t, plugin, pipelineID, c, p)
 	return &ConnectorServiceCreateCall{Call: call}
 }
 
@@ -518,35 +520,35 @@ type ConnectorServiceCreateCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *ConnectorServiceCreateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceCreateCall {
-	c.Call = c.Call.Return(arg0, arg1)
-	return c
+func (c_2 *ConnectorServiceCreateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.Return(arg0, arg1)
+	return c_2
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *ConnectorServiceCreateCall) Do(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
-	c.Call = c.Call.Do(f)
-	return c
+func (c_2 *ConnectorServiceCreateCall) Do(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.Do(f)
+	return c_2
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *ConnectorServiceCreateCall) DoAndReturn(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+func (c_2 *ConnectorServiceCreateCall) DoAndReturn(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.DoAndReturn(f)
+	return c_2
 }
 
 // Delete mocks base method.
-func (m *ConnectorService) Delete(arg0 context.Context, arg1 string, arg2 connector.PluginDispenserFetcher) error {
+func (m *ConnectorService) Delete(ctx context.Context, id string, dispenserFetcher connector.PluginDispenserFetcher) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Delete", ctx, id, dispenserFetcher)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ConnectorServiceMockRecorder) Delete(arg0, arg1, arg2 any) *ConnectorServiceDeleteCall {
+func (mr *ConnectorServiceMockRecorder) Delete(ctx, id, dispenserFetcher any) *ConnectorServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorService)(nil).Delete), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorService)(nil).Delete), ctx, id, dispenserFetcher)
 	return &ConnectorServiceDeleteCall{Call: call}
 }
 
@@ -574,18 +576,18 @@ func (c *ConnectorServiceDeleteCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Get mocks base method.
-func (m *ConnectorService) Get(arg0 context.Context, arg1 string) (*connector.Instance, error) {
+func (m *ConnectorService) Get(ctx context.Context, id string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ConnectorServiceMockRecorder) Get(arg0, arg1 any) *ConnectorServiceGetCall {
+func (mr *ConnectorServiceMockRecorder) Get(ctx, id any) *ConnectorServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorService)(nil).Get), ctx, id)
 	return &ConnectorServiceGetCall{Call: call}
 }
 
@@ -613,17 +615,17 @@ func (c *ConnectorServiceGetCall) DoAndReturn(f func(context.Context, string) (*
 }
 
 // List mocks base method.
-func (m *ConnectorService) List(arg0 context.Context) map[string]*connector.Instance {
+func (m *ConnectorService) List(ctx context.Context) map[string]*connector.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*connector.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *ConnectorServiceMockRecorder) List(arg0 any) *ConnectorServiceListCall {
+func (mr *ConnectorServiceMockRecorder) List(ctx any) *ConnectorServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorService)(nil).List), ctx)
 	return &ConnectorServiceListCall{Call: call}
 }
 
@@ -651,18 +653,18 @@ func (c *ConnectorServiceListCall) DoAndReturn(f func(context.Context) map[strin
 }
 
 // RemoveProcessor mocks base method.
-func (m *ConnectorService) RemoveProcessor(arg0 context.Context, arg1, arg2 string) (*connector.Instance, error) {
+func (m *ConnectorService) RemoveProcessor(ctx context.Context, connectorID, processorID string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveProcessor", ctx, connectorID, processorID)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveProcessor indicates an expected call of RemoveProcessor.
-func (mr *ConnectorServiceMockRecorder) RemoveProcessor(arg0, arg1, arg2 any) *ConnectorServiceRemoveProcessorCall {
+func (mr *ConnectorServiceMockRecorder) RemoveProcessor(ctx, connectorID, processorID any) *ConnectorServiceRemoveProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*ConnectorService)(nil).RemoveProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*ConnectorService)(nil).RemoveProcessor), ctx, connectorID, processorID)
 	return &ConnectorServiceRemoveProcessorCall{Call: call}
 }
 
@@ -690,18 +692,18 @@ func (c *ConnectorServiceRemoveProcessorCall) DoAndReturn(f func(context.Context
 }
 
 // Update mocks base method.
-func (m *ConnectorService) Update(arg0 context.Context, arg1 string, arg2 connector.Config) (*connector.Instance, error) {
+func (m *ConnectorService) Update(ctx context.Context, id string, c connector.Config) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, c)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ConnectorServiceMockRecorder) Update(arg0, arg1, arg2 any) *ConnectorServiceUpdateCall {
+func (mr *ConnectorServiceMockRecorder) Update(ctx, id, c any) *ConnectorServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorService)(nil).Update), ctx, id, c)
 	return &ConnectorServiceUpdateCall{Call: call}
 }
 
@@ -711,27 +713,28 @@ type ConnectorServiceUpdateCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *ConnectorServiceUpdateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.Return(arg0, arg1)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.Return(arg0, arg1)
+	return c_2
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *ConnectorServiceUpdateCall) Do(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.Do(f)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) Do(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.Do(f)
+	return c_2
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *ConnectorServiceUpdateCall) DoAndReturn(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) DoAndReturn(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.DoAndReturn(f)
+	return c_2
 }
 
 // ProcessorService is a mock of ProcessorService interface.
 type ProcessorService struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorServiceMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorServiceMockRecorder is the mock recorder for ProcessorService.
@@ -752,18 +755,18 @@ func (m *ProcessorService) EXPECT() *ProcessorServiceMockRecorder {
 }
 
 // Create mocks base method.
-func (m *ProcessorService) Create(arg0 context.Context, arg1, arg2 string, arg3 processor.Parent, arg4 processor.Config, arg5 processor.ProvisionType, arg6 string) (*processor.Instance, error) {
+func (m *ProcessorService) Create(ctx context.Context, id, plugin string, parent processor.Parent, cfg processor.Config, p processor.ProvisionType, condition string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret := m.ctrl.Call(m, "Create", ctx, id, plugin, parent, cfg, p, condition)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ProcessorServiceMockRecorder) Create(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *ProcessorServiceCreateCall {
+func (mr *ProcessorServiceMockRecorder) Create(ctx, id, plugin, parent, cfg, p, condition any) *ProcessorServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorService)(nil).Create), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorService)(nil).Create), ctx, id, plugin, parent, cfg, p, condition)
 	return &ProcessorServiceCreateCall{Call: call}
 }
 
@@ -791,17 +794,17 @@ func (c *ProcessorServiceCreateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Delete mocks base method.
-func (m *ProcessorService) Delete(arg0 context.Context, arg1 string) error {
+func (m *ProcessorService) Delete(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ProcessorServiceMockRecorder) Delete(arg0, arg1 any) *ProcessorServiceDeleteCall {
+func (mr *ProcessorServiceMockRecorder) Delete(ctx, id any) *ProcessorServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorService)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorService)(nil).Delete), ctx, id)
 	return &ProcessorServiceDeleteCall{Call: call}
 }
 
@@ -829,18 +832,18 @@ func (c *ProcessorServiceDeleteCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Get mocks base method.
-func (m *ProcessorService) Get(arg0 context.Context, arg1 string) (*processor.Instance, error) {
+func (m *ProcessorService) Get(ctx context.Context, id string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ProcessorServiceMockRecorder) Get(arg0, arg1 any) *ProcessorServiceGetCall {
+func (mr *ProcessorServiceMockRecorder) Get(ctx, id any) *ProcessorServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorService)(nil).Get), ctx, id)
 	return &ProcessorServiceGetCall{Call: call}
 }
 
@@ -868,17 +871,17 @@ func (c *ProcessorServiceGetCall) DoAndReturn(f func(context.Context, string) (*
 }
 
 // List mocks base method.
-func (m *ProcessorService) List(arg0 context.Context) map[string]*processor.Instance {
+func (m *ProcessorService) List(ctx context.Context) map[string]*processor.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*processor.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *ProcessorServiceMockRecorder) List(arg0 any) *ProcessorServiceListCall {
+func (mr *ProcessorServiceMockRecorder) List(ctx any) *ProcessorServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorService)(nil).List), ctx)
 	return &ProcessorServiceListCall{Call: call}
 }
 
@@ -906,18 +909,18 @@ func (c *ProcessorServiceListCall) DoAndReturn(f func(context.Context) map[strin
 }
 
 // MakeRunnableProcessor mocks base method.
-func (m *ProcessorService) MakeRunnableProcessor(arg0 context.Context, arg1 *processor.Instance) (*processor.RunnableProcessor, error) {
+func (m *ProcessorService) MakeRunnableProcessor(ctx context.Context, i *processor.Instance) (*processor.RunnableProcessor, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MakeRunnableProcessor", arg0, arg1)
+	ret := m.ctrl.Call(m, "MakeRunnableProcessor", ctx, i)
 	ret0, _ := ret[0].(*processor.RunnableProcessor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // MakeRunnableProcessor indicates an expected call of MakeRunnableProcessor.
-func (mr *ProcessorServiceMockRecorder) MakeRunnableProcessor(arg0, arg1 any) *ProcessorServiceMakeRunnableProcessorCall {
+func (mr *ProcessorServiceMockRecorder) MakeRunnableProcessor(ctx, i any) *ProcessorServiceMakeRunnableProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRunnableProcessor", reflect.TypeOf((*ProcessorService)(nil).MakeRunnableProcessor), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRunnableProcessor", reflect.TypeOf((*ProcessorService)(nil).MakeRunnableProcessor), ctx, i)
 	return &ProcessorServiceMakeRunnableProcessorCall{Call: call}
 }
 
@@ -945,18 +948,18 @@ func (c *ProcessorServiceMakeRunnableProcessorCall) DoAndReturn(f func(context.C
 }
 
 // Update mocks base method.
-func (m *ProcessorService) Update(arg0 context.Context, arg1 string, arg2 processor.Config) (*processor.Instance, error) {
+func (m *ProcessorService) Update(ctx context.Context, id string, cfg processor.Config) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, cfg)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ProcessorServiceMockRecorder) Update(arg0, arg1, arg2 any) *ProcessorServiceUpdateCall {
+func (mr *ProcessorServiceMockRecorder) Update(ctx, id, cfg any) *ProcessorServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorService)(nil).Update), ctx, id, cfg)
 	return &ProcessorServiceUpdateCall{Call: call}
 }
 
@@ -987,6 +990,7 @@ func (c *ProcessorServiceUpdateCall) DoAndReturn(f func(context.Context, string,
 type ConnectorPluginService struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorPluginServiceMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorPluginServiceMockRecorder is the mock recorder for ConnectorPluginService.
@@ -1007,18 +1011,18 @@ func (m *ConnectorPluginService) EXPECT() *ConnectorPluginServiceMockRecorder {
 }
 
 // List mocks base method.
-func (m *ConnectorPluginService) List(arg0 context.Context) (map[string]pconnector.Specification, error) {
+func (m *ConnectorPluginService) List(ctx context.Context) (map[string]pconnector.Specification, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]pconnector.Specification)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // List indicates an expected call of List.
-func (mr *ConnectorPluginServiceMockRecorder) List(arg0 any) *ConnectorPluginServiceListCall {
+func (mr *ConnectorPluginServiceMockRecorder) List(ctx any) *ConnectorPluginServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorPluginService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorPluginService)(nil).List), ctx)
 	return &ConnectorPluginServiceListCall{Call: call}
 }
 
@@ -1046,18 +1050,18 @@ func (c *ConnectorPluginServiceListCall) DoAndReturn(f func(context.Context) (ma
 }
 
 // NewDispenser mocks base method.
-func (m *ConnectorPluginService) NewDispenser(arg0 log.CtxLogger, arg1, arg2 string) (connector0.Dispenser, error) {
+func (m *ConnectorPluginService) NewDispenser(logger log.CtxLogger, name, connectorID string) (connector0.Dispenser, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "NewDispenser", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "NewDispenser", logger, name, connectorID)
 	ret0, _ := ret[0].(connector0.Dispenser)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // NewDispenser indicates an expected call of NewDispenser.
-func (mr *ConnectorPluginServiceMockRecorder) NewDispenser(arg0, arg1, arg2 any) *ConnectorPluginServiceNewDispenserCall {
+func (mr *ConnectorPluginServiceMockRecorder) NewDispenser(logger, name, connectorID any) *ConnectorPluginServiceNewDispenserCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDispenser", reflect.TypeOf((*ConnectorPluginService)(nil).NewDispenser), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDispenser", reflect.TypeOf((*ConnectorPluginService)(nil).NewDispenser), logger, name, connectorID)
 	return &ConnectorPluginServiceNewDispenserCall{Call: call}
 }
 
@@ -1085,17 +1089,17 @@ func (c *ConnectorPluginServiceNewDispenserCall) DoAndReturn(f func(log.CtxLogge
 }
 
 // ValidateDestinationConfig mocks base method.
-func (m *ConnectorPluginService) ValidateDestinationConfig(arg0 context.Context, arg1 string, arg2 map[string]string) error {
+func (m *ConnectorPluginService) ValidateDestinationConfig(ctx context.Context, name string, settings map[string]string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ValidateDestinationConfig", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "ValidateDestinationConfig", ctx, name, settings)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ValidateDestinationConfig indicates an expected call of ValidateDestinationConfig.
-func (mr *ConnectorPluginServiceMockRecorder) ValidateDestinationConfig(arg0, arg1, arg2 any) *ConnectorPluginServiceValidateDestinationConfigCall {
+func (mr *ConnectorPluginServiceMockRecorder) ValidateDestinationConfig(ctx, name, settings any) *ConnectorPluginServiceValidateDestinationConfigCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDestinationConfig", reflect.TypeOf((*ConnectorPluginService)(nil).ValidateDestinationConfig), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDestinationConfig", reflect.TypeOf((*ConnectorPluginService)(nil).ValidateDestinationConfig), ctx, name, settings)
 	return &ConnectorPluginServiceValidateDestinationConfigCall{Call: call}
 }
 
@@ -1123,17 +1127,17 @@ func (c *ConnectorPluginServiceValidateDestinationConfigCall) DoAndReturn(f func
 }
 
 // ValidateSourceConfig mocks base method.
-func (m *ConnectorPluginService) ValidateSourceConfig(arg0 context.Context, arg1 string, arg2 map[string]string) error {
+func (m *ConnectorPluginService) ValidateSourceConfig(ctx context.Context, name string, settings map[string]string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ValidateSourceConfig", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "ValidateSourceConfig", ctx, name, settings)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ValidateSourceConfig indicates an expected call of ValidateSourceConfig.
-func (mr *ConnectorPluginServiceMockRecorder) ValidateSourceConfig(arg0, arg1, arg2 any) *ConnectorPluginServiceValidateSourceConfigCall {
+func (mr *ConnectorPluginServiceMockRecorder) ValidateSourceConfig(ctx, name, settings any) *ConnectorPluginServiceValidateSourceConfigCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateSourceConfig", reflect.TypeOf((*ConnectorPluginService)(nil).ValidateSourceConfig), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateSourceConfig", reflect.TypeOf((*ConnectorPluginService)(nil).ValidateSourceConfig), ctx, name, settings)
 	return &ConnectorPluginServiceValidateSourceConfigCall{Call: call}
 }
 
@@ -1164,6 +1168,7 @@ func (c *ConnectorPluginServiceValidateSourceConfigCall) DoAndReturn(f func(cont
 type ProcessorPluginService struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorPluginServiceMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorPluginServiceMockRecorder is the mock recorder for ProcessorPluginService.
@@ -1184,18 +1189,18 @@ func (m *ProcessorPluginService) EXPECT() *ProcessorPluginServiceMockRecorder {
 }
 
 // List mocks base method.
-func (m *ProcessorPluginService) List(arg0 context.Context) (map[string]sdk.Specification, error) {
+func (m *ProcessorPluginService) List(ctx context.Context) (map[string]sdk.Specification, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]sdk.Specification)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // List indicates an expected call of List.
-func (mr *ProcessorPluginServiceMockRecorder) List(arg0 any) *ProcessorPluginServiceListCall {
+func (mr *ProcessorPluginServiceMockRecorder) List(ctx any) *ProcessorPluginServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorPluginService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorPluginService)(nil).List), ctx)
 	return &ProcessorPluginServiceListCall{Call: call}
 }
 
@@ -1223,18 +1228,18 @@ func (c *ProcessorPluginServiceListCall) DoAndReturn(f func(context.Context) (ma
 }
 
 // NewProcessor mocks base method.
-func (m *ProcessorPluginService) NewProcessor(arg0 context.Context, arg1, arg2 string) (sdk.Processor, error) {
+func (m *ProcessorPluginService) NewProcessor(ctx context.Context, pluginName, id string) (sdk.Processor, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "NewProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "NewProcessor", ctx, pluginName, id)
 	ret0, _ := ret[0].(sdk.Processor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // NewProcessor indicates an expected call of NewProcessor.
-func (mr *ProcessorPluginServiceMockRecorder) NewProcessor(arg0, arg1, arg2 any) *ProcessorPluginServiceNewProcessorCall {
+func (mr *ProcessorPluginServiceMockRecorder) NewProcessor(ctx, pluginName, id any) *ProcessorPluginServiceNewProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewProcessor", reflect.TypeOf((*ProcessorPluginService)(nil).NewProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewProcessor", reflect.TypeOf((*ProcessorPluginService)(nil).NewProcessor), ctx, pluginName, id)
 	return &ProcessorPluginServiceNewProcessorCall{Call: call}
 }
 
@@ -1262,18 +1267,18 @@ func (c *ProcessorPluginServiceNewProcessorCall) DoAndReturn(f func(context.Cont
 }
 
 // RegisterStandalonePlugin mocks base method.
-func (m *ProcessorPluginService) RegisterStandalonePlugin(arg0 context.Context, arg1 string) (string, error) {
+func (m *ProcessorPluginService) RegisterStandalonePlugin(ctx context.Context, path string) (string, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RegisterStandalonePlugin", arg0, arg1)
+	ret := m.ctrl.Call(m, "RegisterStandalonePlugin", ctx, path)
 	ret0, _ := ret[0].(string)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RegisterStandalonePlugin indicates an expected call of RegisterStandalonePlugin.
-func (mr *ProcessorPluginServiceMockRecorder) RegisterStandalonePlugin(arg0, arg1 any) *ProcessorPluginServiceRegisterStandalonePluginCall {
+func (mr *ProcessorPluginServiceMockRecorder) RegisterStandalonePlugin(ctx, path any) *ProcessorPluginServiceRegisterStandalonePluginCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStandalonePlugin", reflect.TypeOf((*ProcessorPluginService)(nil).RegisterStandalonePlugin), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStandalonePlugin", reflect.TypeOf((*ProcessorPluginService)(nil).RegisterStandalonePlugin), ctx, path)
 	return &ProcessorPluginServiceRegisterStandalonePluginCall{Call: call}
 }
 
@@ -1304,6 +1309,7 @@ func (c *ProcessorPluginServiceRegisterStandalonePluginCall) DoAndReturn(f func(
 type LifecycleService struct {
 	ctrl     *gomock.Controller
 	recorder *LifecycleServiceMockRecorder
+	isgomock struct{}
 }
 
 // LifecycleServiceMockRecorder is the mock recorder for LifecycleService.
@@ -1324,17 +1330,17 @@ func (m *LifecycleService) EXPECT() *LifecycleServiceMockRecorder {
 }
 
 // Start mocks base method.
-func (m *LifecycleService) Start(arg0 context.Context, arg1 string) error {
+func (m *LifecycleService) Start(ctx context.Context, pipelineID string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Start", arg0, arg1)
+	ret := m.ctrl.Call(m, "Start", ctx, pipelineID)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Start indicates an expected call of Start.
-func (mr *LifecycleServiceMockRecorder) Start(arg0, arg1 any) *LifecycleServiceStartCall {
+func (mr *LifecycleServiceMockRecorder) Start(ctx, pipelineID any) *LifecycleServiceStartCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*LifecycleService)(nil).Start), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*LifecycleService)(nil).Start), ctx, pipelineID)
 	return &LifecycleServiceStartCall{Call: call}
 }
 
@@ -1362,17 +1368,17 @@ func (c *LifecycleServiceStartCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Stop mocks base method.
-func (m *LifecycleService) Stop(arg0 context.Context, arg1 string, arg2 bool) error {
+func (m *LifecycleService) Stop(ctx context.Context, pipelineID string, force bool) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Stop", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Stop", ctx, pipelineID, force)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Stop indicates an expected call of Stop.
-func (mr *LifecycleServiceMockRecorder) Stop(arg0, arg1, arg2 any) *LifecycleServiceStopCall {
+func (mr *LifecycleServiceMockRecorder) Stop(ctx, pipelineID, force any) *LifecycleServiceStopCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*LifecycleService)(nil).Stop), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*LifecycleService)(nil).Stop), ctx, pipelineID, force)
 	return &LifecycleServiceStopCall{Call: call}
 }
 
diff --git a/pkg/plugin/connector/mock/plugin.go b/pkg/plugin/connector/mock/plugin.go
index 22a641a02..1cd4b24e4 100644
--- a/pkg/plugin/connector/mock/plugin.go
+++ b/pkg/plugin/connector/mock/plugin.go
@@ -22,6 +22,7 @@ import (
 type Dispenser struct {
 	ctrl     *gomock.Controller
 	recorder *DispenserMockRecorder
+	isgomock struct{}
 }
 
 // DispenserMockRecorder is the mock recorder for Dispenser.
@@ -162,6 +163,7 @@ func (c *DispenserDispenseSpecifierCall) DoAndReturn(f func() (connector.Specifi
 type DestinationPlugin struct {
 	ctrl     *gomock.Controller
 	recorder *DestinationPluginMockRecorder
+	isgomock struct{}
 }
 
 // DestinationPluginMockRecorder is the mock recorder for DestinationPlugin.
@@ -534,6 +536,7 @@ func (c *DestinationPluginTeardownCall) DoAndReturn(f func(context.Context, pcon
 type SourcePlugin struct {
 	ctrl     *gomock.Controller
 	recorder *SourcePluginMockRecorder
+	isgomock struct{}
 }
 
 // SourcePluginMockRecorder is the mock recorder for SourcePlugin.
@@ -906,6 +909,7 @@ func (c *SourcePluginTeardownCall) DoAndReturn(f func(context.Context, pconnecto
 type SpecifierPlugin struct {
 	ctrl     *gomock.Controller
 	recorder *SpecifierPluginMockRecorder
+	isgomock struct{}
 }
 
 // SpecifierPluginMockRecorder is the mock recorder for SpecifierPlugin.
diff --git a/pkg/plugin/processor/builtin/impl/avro/mock_decoder.go b/pkg/plugin/processor/builtin/impl/avro/mock_decoder.go
index 23312681d..58debde8c 100644
--- a/pkg/plugin/processor/builtin/impl/avro/mock_decoder.go
+++ b/pkg/plugin/processor/builtin/impl/avro/mock_decoder.go
@@ -21,6 +21,7 @@ import (
 type MockDecoder struct {
 	ctrl     *gomock.Controller
 	recorder *MockDecoderMockRecorder
+	isgomock struct{}
 }
 
 // MockDecoderMockRecorder is the mock recorder for MockDecoder.
diff --git a/pkg/plugin/processor/builtin/impl/avro/mock_encoder.go b/pkg/plugin/processor/builtin/impl/avro/mock_encoder.go
index 030af9aeb..942599360 100644
--- a/pkg/plugin/processor/builtin/impl/avro/mock_encoder.go
+++ b/pkg/plugin/processor/builtin/impl/avro/mock_encoder.go
@@ -21,6 +21,7 @@ import (
 type MockEncoder struct {
 	ctrl     *gomock.Controller
 	recorder *MockEncoderMockRecorder
+	isgomock struct{}
 }
 
 // MockEncoderMockRecorder is the mock recorder for MockEncoder.
diff --git a/pkg/plugin/processor/mock/processor.go b/pkg/plugin/processor/mock/processor.go
index df1b83606..74e265491 100644
--- a/pkg/plugin/processor/mock/processor.go
+++ b/pkg/plugin/processor/mock/processor.go
@@ -24,6 +24,7 @@ type Processor struct {
 	sdk.UnimplementedProcessor
 	ctrl     *gomock.Controller
 	recorder *ProcessorMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorMockRecorder is the mock recorder for Processor.
diff --git a/pkg/plugin/processor/mock/registry.go b/pkg/plugin/processor/mock/registry.go
index d1a0c41dd..86eb2faf7 100644
--- a/pkg/plugin/processor/mock/registry.go
+++ b/pkg/plugin/processor/mock/registry.go
@@ -22,6 +22,7 @@ import (
 type Registry struct {
 	ctrl     *gomock.Controller
 	recorder *RegistryMockRecorder
+	isgomock struct{}
 }
 
 // RegistryMockRecorder is the mock recorder for Registry.
@@ -122,6 +123,7 @@ func (c *RegistryNewProcessorCall) DoAndReturn(f func(context.Context, plugin.Fu
 type StandaloneRegistry struct {
 	ctrl     *gomock.Controller
 	recorder *StandaloneRegistryMockRecorder
+	isgomock struct{}
 }
 
 // StandaloneRegistryMockRecorder is the mock recorder for StandaloneRegistry.
diff --git a/pkg/processor/mock/plugin_service.go b/pkg/processor/mock/plugin_service.go
index feab4f8a2..a6f9c3074 100644
--- a/pkg/processor/mock/plugin_service.go
+++ b/pkg/processor/mock/plugin_service.go
@@ -21,6 +21,7 @@ import (
 type PluginService struct {
 	ctrl     *gomock.Controller
 	recorder *PluginServiceMockRecorder
+	isgomock struct{}
 }
 
 // PluginServiceMockRecorder is the mock recorder for PluginService.
@@ -41,18 +42,18 @@ func (m *PluginService) EXPECT() *PluginServiceMockRecorder {
 }
 
 // NewProcessor mocks base method.
-func (m *PluginService) NewProcessor(arg0 context.Context, arg1, arg2 string) (sdk.Processor, error) {
+func (m *PluginService) NewProcessor(ctx context.Context, pluginName, id string) (sdk.Processor, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "NewProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "NewProcessor", ctx, pluginName, id)
 	ret0, _ := ret[0].(sdk.Processor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // NewProcessor indicates an expected call of NewProcessor.
-func (mr *PluginServiceMockRecorder) NewProcessor(arg0, arg1, arg2 any) *PluginServiceNewProcessorCall {
+func (mr *PluginServiceMockRecorder) NewProcessor(ctx, pluginName, id any) *PluginServiceNewProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewProcessor", reflect.TypeOf((*PluginService)(nil).NewProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewProcessor", reflect.TypeOf((*PluginService)(nil).NewProcessor), ctx, pluginName, id)
 	return &PluginServiceNewProcessorCall{Call: call}
 }
 
diff --git a/pkg/provisioning/mock/provisioning.go b/pkg/provisioning/mock/provisioning.go
index ae298ff97..5454818af 100644
--- a/pkg/provisioning/mock/provisioning.go
+++ b/pkg/provisioning/mock/provisioning.go
@@ -25,6 +25,7 @@ import (
 type PipelineService struct {
 	ctrl     *gomock.Controller
 	recorder *PipelineServiceMockRecorder
+	isgomock struct{}
 }
 
 // PipelineServiceMockRecorder is the mock recorder for PipelineService.
@@ -45,18 +46,18 @@ func (m *PipelineService) EXPECT() *PipelineServiceMockRecorder {
 }
 
 // AddConnector mocks base method.
-func (m *PipelineService) AddConnector(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) AddConnector(ctx context.Context, pipelineID, connectorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddConnector", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddConnector", ctx, pipelineID, connectorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddConnector indicates an expected call of AddConnector.
-func (mr *PipelineServiceMockRecorder) AddConnector(arg0, arg1, arg2 any) *PipelineServiceAddConnectorCall {
+func (mr *PipelineServiceMockRecorder) AddConnector(ctx, pipelineID, connectorID any) *PipelineServiceAddConnectorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnector", reflect.TypeOf((*PipelineService)(nil).AddConnector), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnector", reflect.TypeOf((*PipelineService)(nil).AddConnector), ctx, pipelineID, connectorID)
 	return &PipelineServiceAddConnectorCall{Call: call}
 }
 
@@ -84,18 +85,18 @@ func (c *PipelineServiceAddConnectorCall) DoAndReturn(f func(context.Context, st
 }
 
 // AddProcessor mocks base method.
-func (m *PipelineService) AddProcessor(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) AddProcessor(ctx context.Context, pipelineID, processorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddProcessor", ctx, pipelineID, processorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddProcessor indicates an expected call of AddProcessor.
-func (mr *PipelineServiceMockRecorder) AddProcessor(arg0, arg1, arg2 any) *PipelineServiceAddProcessorCall {
+func (mr *PipelineServiceMockRecorder) AddProcessor(ctx, pipelineID, processorID any) *PipelineServiceAddProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*PipelineService)(nil).AddProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*PipelineService)(nil).AddProcessor), ctx, pipelineID, processorID)
 	return &PipelineServiceAddProcessorCall{Call: call}
 }
 
@@ -123,18 +124,18 @@ func (c *PipelineServiceAddProcessorCall) DoAndReturn(f func(context.Context, st
 }
 
 // Create mocks base method.
-func (m *PipelineService) Create(arg0 context.Context, arg1 string, arg2 pipeline.Config, arg3 pipeline.ProvisionType) (*pipeline.Instance, error) {
+func (m *PipelineService) Create(ctx context.Context, id string, cfg pipeline.Config, p pipeline.ProvisionType) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Create", ctx, id, cfg, p)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *PipelineServiceMockRecorder) Create(arg0, arg1, arg2, arg3 any) *PipelineServiceCreateCall {
+func (mr *PipelineServiceMockRecorder) Create(ctx, id, cfg, p any) *PipelineServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineService)(nil).Create), arg0, arg1, arg2, arg3)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineService)(nil).Create), ctx, id, cfg, p)
 	return &PipelineServiceCreateCall{Call: call}
 }
 
@@ -162,17 +163,17 @@ func (c *PipelineServiceCreateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Delete mocks base method.
-func (m *PipelineService) Delete(arg0 context.Context, arg1 string) error {
+func (m *PipelineService) Delete(ctx context.Context, pipelineID string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, pipelineID)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *PipelineServiceMockRecorder) Delete(arg0, arg1 any) *PipelineServiceDeleteCall {
+func (mr *PipelineServiceMockRecorder) Delete(ctx, pipelineID any) *PipelineServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineService)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineService)(nil).Delete), ctx, pipelineID)
 	return &PipelineServiceDeleteCall{Call: call}
 }
 
@@ -200,18 +201,18 @@ func (c *PipelineServiceDeleteCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Get mocks base method.
-func (m *PipelineService) Get(arg0 context.Context, arg1 string) (*pipeline.Instance, error) {
+func (m *PipelineService) Get(ctx context.Context, id string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *PipelineServiceMockRecorder) Get(arg0, arg1 any) *PipelineServiceGetCall {
+func (mr *PipelineServiceMockRecorder) Get(ctx, id any) *PipelineServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineService)(nil).Get), ctx, id)
 	return &PipelineServiceGetCall{Call: call}
 }
 
@@ -239,17 +240,17 @@ func (c *PipelineServiceGetCall) DoAndReturn(f func(context.Context, string) (*p
 }
 
 // List mocks base method.
-func (m *PipelineService) List(arg0 context.Context) map[string]*pipeline.Instance {
+func (m *PipelineService) List(ctx context.Context) map[string]*pipeline.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*pipeline.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *PipelineServiceMockRecorder) List(arg0 any) *PipelineServiceListCall {
+func (mr *PipelineServiceMockRecorder) List(ctx any) *PipelineServiceListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineService)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineService)(nil).List), ctx)
 	return &PipelineServiceListCall{Call: call}
 }
 
@@ -277,18 +278,18 @@ func (c *PipelineServiceListCall) DoAndReturn(f func(context.Context) map[string
 }
 
 // RemoveConnector mocks base method.
-func (m *PipelineService) RemoveConnector(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) RemoveConnector(ctx context.Context, pipelineID, connectorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveConnector", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveConnector", ctx, pipelineID, connectorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveConnector indicates an expected call of RemoveConnector.
-func (mr *PipelineServiceMockRecorder) RemoveConnector(arg0, arg1, arg2 any) *PipelineServiceRemoveConnectorCall {
+func (mr *PipelineServiceMockRecorder) RemoveConnector(ctx, pipelineID, connectorID any) *PipelineServiceRemoveConnectorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveConnector", reflect.TypeOf((*PipelineService)(nil).RemoveConnector), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveConnector", reflect.TypeOf((*PipelineService)(nil).RemoveConnector), ctx, pipelineID, connectorID)
 	return &PipelineServiceRemoveConnectorCall{Call: call}
 }
 
@@ -316,18 +317,18 @@ func (c *PipelineServiceRemoveConnectorCall) DoAndReturn(f func(context.Context,
 }
 
 // RemoveProcessor mocks base method.
-func (m *PipelineService) RemoveProcessor(arg0 context.Context, arg1, arg2 string) (*pipeline.Instance, error) {
+func (m *PipelineService) RemoveProcessor(ctx context.Context, pipelineID, processorID string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveProcessor", ctx, pipelineID, processorID)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveProcessor indicates an expected call of RemoveProcessor.
-func (mr *PipelineServiceMockRecorder) RemoveProcessor(arg0, arg1, arg2 any) *PipelineServiceRemoveProcessorCall {
+func (mr *PipelineServiceMockRecorder) RemoveProcessor(ctx, pipelineID, processorID any) *PipelineServiceRemoveProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*PipelineService)(nil).RemoveProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*PipelineService)(nil).RemoveProcessor), ctx, pipelineID, processorID)
 	return &PipelineServiceRemoveProcessorCall{Call: call}
 }
 
@@ -355,18 +356,18 @@ func (c *PipelineServiceRemoveProcessorCall) DoAndReturn(f func(context.Context,
 }
 
 // Update mocks base method.
-func (m *PipelineService) Update(arg0 context.Context, arg1 string, arg2 pipeline.Config) (*pipeline.Instance, error) {
+func (m *PipelineService) Update(ctx context.Context, pipelineID string, cfg pipeline.Config) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, pipelineID, cfg)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *PipelineServiceMockRecorder) Update(arg0, arg1, arg2 any) *PipelineServiceUpdateCall {
+func (mr *PipelineServiceMockRecorder) Update(ctx, pipelineID, cfg any) *PipelineServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineService)(nil).Update), ctx, pipelineID, cfg)
 	return &PipelineServiceUpdateCall{Call: call}
 }
 
@@ -394,18 +395,18 @@ func (c *PipelineServiceUpdateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // UpdateDLQ mocks base method.
-func (m *PipelineService) UpdateDLQ(arg0 context.Context, arg1 string, arg2 pipeline.DLQ) (*pipeline.Instance, error) {
+func (m *PipelineService) UpdateDLQ(ctx context.Context, pipelineID string, cfg pipeline.DLQ) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateDLQ", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "UpdateDLQ", ctx, pipelineID, cfg)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UpdateDLQ indicates an expected call of UpdateDLQ.
-func (mr *PipelineServiceMockRecorder) UpdateDLQ(arg0, arg1, arg2 any) *PipelineServiceUpdateDLQCall {
+func (mr *PipelineServiceMockRecorder) UpdateDLQ(ctx, pipelineID, cfg any) *PipelineServiceUpdateDLQCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineService)(nil).UpdateDLQ), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineService)(nil).UpdateDLQ), ctx, pipelineID, cfg)
 	return &PipelineServiceUpdateDLQCall{Call: call}
 }
 
@@ -436,6 +437,7 @@ func (c *PipelineServiceUpdateDLQCall) DoAndReturn(f func(context.Context, strin
 type ConnectorService struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorServiceMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorServiceMockRecorder is the mock recorder for ConnectorService.
@@ -456,18 +458,18 @@ func (m *ConnectorService) EXPECT() *ConnectorServiceMockRecorder {
 }
 
 // AddProcessor mocks base method.
-func (m *ConnectorService) AddProcessor(arg0 context.Context, arg1, arg2 string) (*connector.Instance, error) {
+func (m *ConnectorService) AddProcessor(ctx context.Context, connectorID, processorID string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "AddProcessor", ctx, connectorID, processorID)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // AddProcessor indicates an expected call of AddProcessor.
-func (mr *ConnectorServiceMockRecorder) AddProcessor(arg0, arg1, arg2 any) *ConnectorServiceAddProcessorCall {
+func (mr *ConnectorServiceMockRecorder) AddProcessor(ctx, connectorID, processorID any) *ConnectorServiceAddProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*ConnectorService)(nil).AddProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProcessor", reflect.TypeOf((*ConnectorService)(nil).AddProcessor), ctx, connectorID, processorID)
 	return &ConnectorServiceAddProcessorCall{Call: call}
 }
 
@@ -495,18 +497,18 @@ func (c *ConnectorServiceAddProcessorCall) DoAndReturn(f func(context.Context, s
 }
 
 // Create mocks base method.
-func (m *ConnectorService) Create(arg0 context.Context, arg1 string, arg2 connector.Type, arg3, arg4 string, arg5 connector.Config, arg6 connector.ProvisionType) (*connector.Instance, error) {
+func (m *ConnectorService) Create(ctx context.Context, id string, t connector.Type, plugin, pipelineID string, c connector.Config, p connector.ProvisionType) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret := m.ctrl.Call(m, "Create", ctx, id, t, plugin, pipelineID, c, p)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ConnectorServiceMockRecorder) Create(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *ConnectorServiceCreateCall {
+func (mr *ConnectorServiceMockRecorder) Create(ctx, id, t, plugin, pipelineID, c, p any) *ConnectorServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorService)(nil).Create), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorService)(nil).Create), ctx, id, t, plugin, pipelineID, c, p)
 	return &ConnectorServiceCreateCall{Call: call}
 }
 
@@ -516,35 +518,35 @@ type ConnectorServiceCreateCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *ConnectorServiceCreateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceCreateCall {
-	c.Call = c.Call.Return(arg0, arg1)
-	return c
+func (c_2 *ConnectorServiceCreateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.Return(arg0, arg1)
+	return c_2
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *ConnectorServiceCreateCall) Do(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
-	c.Call = c.Call.Do(f)
-	return c
+func (c_2 *ConnectorServiceCreateCall) Do(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.Do(f)
+	return c_2
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *ConnectorServiceCreateCall) DoAndReturn(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+func (c_2 *ConnectorServiceCreateCall) DoAndReturn(f func(context.Context, string, connector.Type, string, string, connector.Config, connector.ProvisionType) (*connector.Instance, error)) *ConnectorServiceCreateCall {
+	c_2.Call = c_2.Call.DoAndReturn(f)
+	return c_2
 }
 
 // Delete mocks base method.
-func (m *ConnectorService) Delete(arg0 context.Context, arg1 string, arg2 connector.PluginDispenserFetcher) error {
+func (m *ConnectorService) Delete(ctx context.Context, id string, dispenserFetcher connector.PluginDispenserFetcher) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Delete", ctx, id, dispenserFetcher)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ConnectorServiceMockRecorder) Delete(arg0, arg1, arg2 any) *ConnectorServiceDeleteCall {
+func (mr *ConnectorServiceMockRecorder) Delete(ctx, id, dispenserFetcher any) *ConnectorServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorService)(nil).Delete), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorService)(nil).Delete), ctx, id, dispenserFetcher)
 	return &ConnectorServiceDeleteCall{Call: call}
 }
 
@@ -572,18 +574,18 @@ func (c *ConnectorServiceDeleteCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Get mocks base method.
-func (m *ConnectorService) Get(arg0 context.Context, arg1 string) (*connector.Instance, error) {
+func (m *ConnectorService) Get(ctx context.Context, id string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ConnectorServiceMockRecorder) Get(arg0, arg1 any) *ConnectorServiceGetCall {
+func (mr *ConnectorServiceMockRecorder) Get(ctx, id any) *ConnectorServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorService)(nil).Get), ctx, id)
 	return &ConnectorServiceGetCall{Call: call}
 }
 
@@ -611,18 +613,18 @@ func (c *ConnectorServiceGetCall) DoAndReturn(f func(context.Context, string) (*
 }
 
 // RemoveProcessor mocks base method.
-func (m *ConnectorService) RemoveProcessor(arg0 context.Context, arg1, arg2 string) (*connector.Instance, error) {
+func (m *ConnectorService) RemoveProcessor(ctx context.Context, connectorID, processorID string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveProcessor", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "RemoveProcessor", ctx, connectorID, processorID)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // RemoveProcessor indicates an expected call of RemoveProcessor.
-func (mr *ConnectorServiceMockRecorder) RemoveProcessor(arg0, arg1, arg2 any) *ConnectorServiceRemoveProcessorCall {
+func (mr *ConnectorServiceMockRecorder) RemoveProcessor(ctx, connectorID, processorID any) *ConnectorServiceRemoveProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*ConnectorService)(nil).RemoveProcessor), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProcessor", reflect.TypeOf((*ConnectorService)(nil).RemoveProcessor), ctx, connectorID, processorID)
 	return &ConnectorServiceRemoveProcessorCall{Call: call}
 }
 
@@ -650,18 +652,18 @@ func (c *ConnectorServiceRemoveProcessorCall) DoAndReturn(f func(context.Context
 }
 
 // Update mocks base method.
-func (m *ConnectorService) Update(arg0 context.Context, arg1 string, arg2 connector.Config) (*connector.Instance, error) {
+func (m *ConnectorService) Update(ctx context.Context, id string, c connector.Config) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, c)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ConnectorServiceMockRecorder) Update(arg0, arg1, arg2 any) *ConnectorServiceUpdateCall {
+func (mr *ConnectorServiceMockRecorder) Update(ctx, id, c any) *ConnectorServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorService)(nil).Update), ctx, id, c)
 	return &ConnectorServiceUpdateCall{Call: call}
 }
 
@@ -671,27 +673,28 @@ type ConnectorServiceUpdateCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *ConnectorServiceUpdateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.Return(arg0, arg1)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) Return(arg0 *connector.Instance, arg1 error) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.Return(arg0, arg1)
+	return c_2
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *ConnectorServiceUpdateCall) Do(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.Do(f)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) Do(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.Do(f)
+	return c_2
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *ConnectorServiceUpdateCall) DoAndReturn(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+func (c_2 *ConnectorServiceUpdateCall) DoAndReturn(f func(context.Context, string, connector.Config) (*connector.Instance, error)) *ConnectorServiceUpdateCall {
+	c_2.Call = c_2.Call.DoAndReturn(f)
+	return c_2
 }
 
 // ProcessorService is a mock of ProcessorService interface.
 type ProcessorService struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorServiceMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorServiceMockRecorder is the mock recorder for ProcessorService.
@@ -712,18 +715,18 @@ func (m *ProcessorService) EXPECT() *ProcessorServiceMockRecorder {
 }
 
 // Create mocks base method.
-func (m *ProcessorService) Create(arg0 context.Context, arg1, arg2 string, arg3 processor.Parent, arg4 processor.Config, arg5 processor.ProvisionType, arg6 string) (*processor.Instance, error) {
+func (m *ProcessorService) Create(ctx context.Context, id, plugin string, parent processor.Parent, cfg processor.Config, p processor.ProvisionType, condition string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret := m.ctrl.Call(m, "Create", ctx, id, plugin, parent, cfg, p, condition)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ProcessorServiceMockRecorder) Create(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *ProcessorServiceCreateCall {
+func (mr *ProcessorServiceMockRecorder) Create(ctx, id, plugin, parent, cfg, p, condition any) *ProcessorServiceCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorService)(nil).Create), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorService)(nil).Create), ctx, id, plugin, parent, cfg, p, condition)
 	return &ProcessorServiceCreateCall{Call: call}
 }
 
@@ -751,17 +754,17 @@ func (c *ProcessorServiceCreateCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Delete mocks base method.
-func (m *ProcessorService) Delete(arg0 context.Context, arg1 string) error {
+func (m *ProcessorService) Delete(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ProcessorServiceMockRecorder) Delete(arg0, arg1 any) *ProcessorServiceDeleteCall {
+func (mr *ProcessorServiceMockRecorder) Delete(ctx, id any) *ProcessorServiceDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorService)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorService)(nil).Delete), ctx, id)
 	return &ProcessorServiceDeleteCall{Call: call}
 }
 
@@ -789,18 +792,18 @@ func (c *ProcessorServiceDeleteCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Get mocks base method.
-func (m *ProcessorService) Get(arg0 context.Context, arg1 string) (*processor.Instance, error) {
+func (m *ProcessorService) Get(ctx context.Context, id string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ProcessorServiceMockRecorder) Get(arg0, arg1 any) *ProcessorServiceGetCall {
+func (mr *ProcessorServiceMockRecorder) Get(ctx, id any) *ProcessorServiceGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorService)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorService)(nil).Get), ctx, id)
 	return &ProcessorServiceGetCall{Call: call}
 }
 
@@ -828,18 +831,18 @@ func (c *ProcessorServiceGetCall) DoAndReturn(f func(context.Context, string) (*
 }
 
 // MakeRunnableProcessor mocks base method.
-func (m *ProcessorService) MakeRunnableProcessor(arg0 context.Context, arg1 *processor.Instance) (*processor.RunnableProcessor, error) {
+func (m *ProcessorService) MakeRunnableProcessor(ctx context.Context, i *processor.Instance) (*processor.RunnableProcessor, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MakeRunnableProcessor", arg0, arg1)
+	ret := m.ctrl.Call(m, "MakeRunnableProcessor", ctx, i)
 	ret0, _ := ret[0].(*processor.RunnableProcessor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // MakeRunnableProcessor indicates an expected call of MakeRunnableProcessor.
-func (mr *ProcessorServiceMockRecorder) MakeRunnableProcessor(arg0, arg1 any) *ProcessorServiceMakeRunnableProcessorCall {
+func (mr *ProcessorServiceMockRecorder) MakeRunnableProcessor(ctx, i any) *ProcessorServiceMakeRunnableProcessorCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRunnableProcessor", reflect.TypeOf((*ProcessorService)(nil).MakeRunnableProcessor), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRunnableProcessor", reflect.TypeOf((*ProcessorService)(nil).MakeRunnableProcessor), ctx, i)
 	return &ProcessorServiceMakeRunnableProcessorCall{Call: call}
 }
 
@@ -867,18 +870,18 @@ func (c *ProcessorServiceMakeRunnableProcessorCall) DoAndReturn(f func(context.C
 }
 
 // Update mocks base method.
-func (m *ProcessorService) Update(arg0 context.Context, arg1 string, arg2 processor.Config) (*processor.Instance, error) {
+func (m *ProcessorService) Update(ctx context.Context, id string, cfg processor.Config) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, cfg)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ProcessorServiceMockRecorder) Update(arg0, arg1, arg2 any) *ProcessorServiceUpdateCall {
+func (mr *ProcessorServiceMockRecorder) Update(ctx, id, cfg any) *ProcessorServiceUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorService)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorService)(nil).Update), ctx, id, cfg)
 	return &ProcessorServiceUpdateCall{Call: call}
 }
 
@@ -909,6 +912,7 @@ func (c *ProcessorServiceUpdateCall) DoAndReturn(f func(context.Context, string,
 type ConnectorPluginService struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorPluginServiceMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorPluginServiceMockRecorder is the mock recorder for ConnectorPluginService.
@@ -929,18 +933,18 @@ func (m *ConnectorPluginService) EXPECT() *ConnectorPluginServiceMockRecorder {
 }
 
 // NewDispenser mocks base method.
-func (m *ConnectorPluginService) NewDispenser(arg0 log.CtxLogger, arg1, arg2 string) (connector0.Dispenser, error) {
+func (m *ConnectorPluginService) NewDispenser(ctx log.CtxLogger, name, connectorID string) (connector0.Dispenser, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "NewDispenser", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "NewDispenser", ctx, name, connectorID)
 	ret0, _ := ret[0].(connector0.Dispenser)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // NewDispenser indicates an expected call of NewDispenser.
-func (mr *ConnectorPluginServiceMockRecorder) NewDispenser(arg0, arg1, arg2 any) *ConnectorPluginServiceNewDispenserCall {
+func (mr *ConnectorPluginServiceMockRecorder) NewDispenser(ctx, name, connectorID any) *ConnectorPluginServiceNewDispenserCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDispenser", reflect.TypeOf((*ConnectorPluginService)(nil).NewDispenser), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDispenser", reflect.TypeOf((*ConnectorPluginService)(nil).NewDispenser), ctx, name, connectorID)
 	return &ConnectorPluginServiceNewDispenserCall{Call: call}
 }
 
@@ -971,6 +975,7 @@ func (c *ConnectorPluginServiceNewDispenserCall) DoAndReturn(f func(log.CtxLogge
 type LifecycleService struct {
 	ctrl     *gomock.Controller
 	recorder *LifecycleServiceMockRecorder
+	isgomock struct{}
 }
 
 // LifecycleServiceMockRecorder is the mock recorder for LifecycleService.
@@ -991,17 +996,17 @@ func (m *LifecycleService) EXPECT() *LifecycleServiceMockRecorder {
 }
 
 // Start mocks base method.
-func (m *LifecycleService) Start(arg0 context.Context, arg1 string) error {
+func (m *LifecycleService) Start(ctx context.Context, pipelineID string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Start", arg0, arg1)
+	ret := m.ctrl.Call(m, "Start", ctx, pipelineID)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Start indicates an expected call of Start.
-func (mr *LifecycleServiceMockRecorder) Start(arg0, arg1 any) *LifecycleServiceStartCall {
+func (mr *LifecycleServiceMockRecorder) Start(ctx, pipelineID any) *LifecycleServiceStartCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*LifecycleService)(nil).Start), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*LifecycleService)(nil).Start), ctx, pipelineID)
 	return &LifecycleServiceStartCall{Call: call}
 }
 
@@ -1029,17 +1034,17 @@ func (c *LifecycleServiceStartCall) DoAndReturn(f func(context.Context, string)
 }
 
 // Stop mocks base method.
-func (m *LifecycleService) Stop(arg0 context.Context, arg1 string, arg2 bool) error {
+func (m *LifecycleService) Stop(ctx context.Context, pipelineID string, force bool) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Stop", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Stop", ctx, pipelineID, force)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Stop indicates an expected call of Stop.
-func (mr *LifecycleServiceMockRecorder) Stop(arg0, arg1, arg2 any) *LifecycleServiceStopCall {
+func (mr *LifecycleServiceMockRecorder) Stop(ctx, pipelineID, force any) *LifecycleServiceStopCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*LifecycleService)(nil).Stop), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*LifecycleService)(nil).Stop), ctx, pipelineID, force)
 	return &LifecycleServiceStopCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/connector.go b/pkg/web/api/mock/connector.go
index 74b28276c..114cb206c 100644
--- a/pkg/web/api/mock/connector.go
+++ b/pkg/web/api/mock/connector.go
@@ -22,6 +22,7 @@ import (
 type ConnectorOrchestrator struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorOrchestratorMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorOrchestratorMockRecorder is the mock recorder for ConnectorOrchestrator.
@@ -42,18 +43,18 @@ func (m *ConnectorOrchestrator) EXPECT() *ConnectorOrchestratorMockRecorder {
 }
 
 // Create mocks base method.
-func (m *ConnectorOrchestrator) Create(arg0 context.Context, arg1 connector.Type, arg2, arg3 string, arg4 connector.Config) (*connector.Instance, error) {
+func (m *ConnectorOrchestrator) Create(ctx context.Context, t connector.Type, plugin, pipelineID string, config connector.Config) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4)
+	ret := m.ctrl.Call(m, "Create", ctx, t, plugin, pipelineID, config)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ConnectorOrchestratorMockRecorder) Create(arg0, arg1, arg2, arg3, arg4 any) *ConnectorOrchestratorCreateCall {
+func (mr *ConnectorOrchestratorMockRecorder) Create(ctx, t, plugin, pipelineID, config any) *ConnectorOrchestratorCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorOrchestrator)(nil).Create), arg0, arg1, arg2, arg3, arg4)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ConnectorOrchestrator)(nil).Create), ctx, t, plugin, pipelineID, config)
 	return &ConnectorOrchestratorCreateCall{Call: call}
 }
 
@@ -81,17 +82,17 @@ func (c *ConnectorOrchestratorCreateCall) DoAndReturn(f func(context.Context, co
 }
 
 // Delete mocks base method.
-func (m *ConnectorOrchestrator) Delete(arg0 context.Context, arg1 string) error {
+func (m *ConnectorOrchestrator) Delete(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ConnectorOrchestratorMockRecorder) Delete(arg0, arg1 any) *ConnectorOrchestratorDeleteCall {
+func (mr *ConnectorOrchestratorMockRecorder) Delete(ctx, id any) *ConnectorOrchestratorDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorOrchestrator)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ConnectorOrchestrator)(nil).Delete), ctx, id)
 	return &ConnectorOrchestratorDeleteCall{Call: call}
 }
 
@@ -119,18 +120,18 @@ func (c *ConnectorOrchestratorDeleteCall) DoAndReturn(f func(context.Context, st
 }
 
 // Get mocks base method.
-func (m *ConnectorOrchestrator) Get(arg0 context.Context, arg1 string) (*connector.Instance, error) {
+func (m *ConnectorOrchestrator) Get(ctx context.Context, id string) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ConnectorOrchestratorMockRecorder) Get(arg0, arg1 any) *ConnectorOrchestratorGetCall {
+func (mr *ConnectorOrchestratorMockRecorder) Get(ctx, id any) *ConnectorOrchestratorGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorOrchestrator)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ConnectorOrchestrator)(nil).Get), ctx, id)
 	return &ConnectorOrchestratorGetCall{Call: call}
 }
 
@@ -158,18 +159,18 @@ func (c *ConnectorOrchestratorGetCall) DoAndReturn(f func(context.Context, strin
 }
 
 // Inspect mocks base method.
-func (m *ConnectorOrchestrator) Inspect(arg0 context.Context, arg1 string) (*inspector.Session, error) {
+func (m *ConnectorOrchestrator) Inspect(ctx context.Context, id string) (*inspector.Session, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Inspect", arg0, arg1)
+	ret := m.ctrl.Call(m, "Inspect", ctx, id)
 	ret0, _ := ret[0].(*inspector.Session)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Inspect indicates an expected call of Inspect.
-func (mr *ConnectorOrchestratorMockRecorder) Inspect(arg0, arg1 any) *ConnectorOrchestratorInspectCall {
+func (mr *ConnectorOrchestratorMockRecorder) Inspect(ctx, id any) *ConnectorOrchestratorInspectCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Inspect", reflect.TypeOf((*ConnectorOrchestrator)(nil).Inspect), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Inspect", reflect.TypeOf((*ConnectorOrchestrator)(nil).Inspect), ctx, id)
 	return &ConnectorOrchestratorInspectCall{Call: call}
 }
 
@@ -197,17 +198,17 @@ func (c *ConnectorOrchestratorInspectCall) DoAndReturn(f func(context.Context, s
 }
 
 // List mocks base method.
-func (m *ConnectorOrchestrator) List(arg0 context.Context) map[string]*connector.Instance {
+func (m *ConnectorOrchestrator) List(ctx context.Context) map[string]*connector.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*connector.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *ConnectorOrchestratorMockRecorder) List(arg0 any) *ConnectorOrchestratorListCall {
+func (mr *ConnectorOrchestratorMockRecorder) List(ctx any) *ConnectorOrchestratorListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorOrchestrator)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorOrchestrator)(nil).List), ctx)
 	return &ConnectorOrchestratorListCall{Call: call}
 }
 
@@ -235,18 +236,18 @@ func (c *ConnectorOrchestratorListCall) DoAndReturn(f func(context.Context) map[
 }
 
 // Update mocks base method.
-func (m *ConnectorOrchestrator) Update(arg0 context.Context, arg1 string, arg2 connector.Config) (*connector.Instance, error) {
+func (m *ConnectorOrchestrator) Update(ctx context.Context, id string, config connector.Config) (*connector.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, config)
 	ret0, _ := ret[0].(*connector.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ConnectorOrchestratorMockRecorder) Update(arg0, arg1, arg2 any) *ConnectorOrchestratorUpdateCall {
+func (mr *ConnectorOrchestratorMockRecorder) Update(ctx, id, config any) *ConnectorOrchestratorUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorOrchestrator)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ConnectorOrchestrator)(nil).Update), ctx, id, config)
 	return &ConnectorOrchestratorUpdateCall{Call: call}
 }
 
@@ -274,17 +275,17 @@ func (c *ConnectorOrchestratorUpdateCall) DoAndReturn(f func(context.Context, st
 }
 
 // Validate mocks base method.
-func (m *ConnectorOrchestrator) Validate(arg0 context.Context, arg1 connector.Type, arg2 string, arg3 connector.Config) error {
+func (m *ConnectorOrchestrator) Validate(ctx context.Context, t connector.Type, plugin string, config connector.Config) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Validate", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Validate", ctx, t, plugin, config)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Validate indicates an expected call of Validate.
-func (mr *ConnectorOrchestratorMockRecorder) Validate(arg0, arg1, arg2, arg3 any) *ConnectorOrchestratorValidateCall {
+func (mr *ConnectorOrchestratorMockRecorder) Validate(ctx, t, plugin, config any) *ConnectorOrchestratorValidateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*ConnectorOrchestrator)(nil).Validate), arg0, arg1, arg2, arg3)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*ConnectorOrchestrator)(nil).Validate), ctx, t, plugin, config)
 	return &ConnectorOrchestratorValidateCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/connector_plugin.go b/pkg/web/api/mock/connector_plugin.go
index ee252364b..b378b8756 100644
--- a/pkg/web/api/mock/connector_plugin.go
+++ b/pkg/web/api/mock/connector_plugin.go
@@ -21,6 +21,7 @@ import (
 type ConnectorPluginOrchestrator struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorPluginOrchestratorMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorPluginOrchestratorMockRecorder is the mock recorder for ConnectorPluginOrchestrator.
@@ -41,18 +42,18 @@ func (m *ConnectorPluginOrchestrator) EXPECT() *ConnectorPluginOrchestratorMockR
 }
 
 // List mocks base method.
-func (m *ConnectorPluginOrchestrator) List(arg0 context.Context) (map[string]pconnector.Specification, error) {
+func (m *ConnectorPluginOrchestrator) List(ctx context.Context) (map[string]pconnector.Specification, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]pconnector.Specification)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // List indicates an expected call of List.
-func (mr *ConnectorPluginOrchestratorMockRecorder) List(arg0 any) *ConnectorPluginOrchestratorListCall {
+func (mr *ConnectorPluginOrchestratorMockRecorder) List(ctx any) *ConnectorPluginOrchestratorListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorPluginOrchestrator)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ConnectorPluginOrchestrator)(nil).List), ctx)
 	return &ConnectorPluginOrchestratorListCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/connector_service.go b/pkg/web/api/mock/connector_service.go
index d1173084b..a72f0b268 100644
--- a/pkg/web/api/mock/connector_service.go
+++ b/pkg/web/api/mock/connector_service.go
@@ -22,6 +22,7 @@ import (
 type ConnectorService_InspectConnectorServer struct {
 	ctrl     *gomock.Controller
 	recorder *ConnectorService_InspectConnectorServerMockRecorder
+	isgomock struct{}
 }
 
 // ConnectorService_InspectConnectorServerMockRecorder is the mock recorder for ConnectorService_InspectConnectorServer.
@@ -80,17 +81,17 @@ func (c *ConnectorService_InspectConnectorServerContextCall) DoAndReturn(f func(
 }
 
 // RecvMsg mocks base method.
-func (m *ConnectorService_InspectConnectorServer) RecvMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RecvMsg", arg0)
+func (m_2 *ConnectorService_InspectConnectorServer) RecvMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *ConnectorService_InspectConnectorServerMockRecorder) RecvMsg(arg0 any) *ConnectorService_InspectConnectorServerRecvMsgCall {
+func (mr *ConnectorService_InspectConnectorServerMockRecorder) RecvMsg(m any) *ConnectorService_InspectConnectorServerRecvMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ConnectorService_InspectConnectorServer)(nil).RecvMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ConnectorService_InspectConnectorServer)(nil).RecvMsg), m)
 	return &ConnectorService_InspectConnectorServerRecvMsgCall{Call: call}
 }
 
@@ -194,17 +195,17 @@ func (c *ConnectorService_InspectConnectorServerSendHeaderCall) DoAndReturn(f fu
 }
 
 // SendMsg mocks base method.
-func (m *ConnectorService_InspectConnectorServer) SendMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMsg", arg0)
+func (m_2 *ConnectorService_InspectConnectorServer) SendMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *ConnectorService_InspectConnectorServerMockRecorder) SendMsg(arg0 any) *ConnectorService_InspectConnectorServerSendMsgCall {
+func (mr *ConnectorService_InspectConnectorServerMockRecorder) SendMsg(m any) *ConnectorService_InspectConnectorServerSendMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ConnectorService_InspectConnectorServer)(nil).SendMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ConnectorService_InspectConnectorServer)(nil).SendMsg), m)
 	return &ConnectorService_InspectConnectorServerSendMsgCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/pipeline.go b/pkg/web/api/mock/pipeline.go
index c6d702c27..12d8b78cf 100644
--- a/pkg/web/api/mock/pipeline.go
+++ b/pkg/web/api/mock/pipeline.go
@@ -21,6 +21,7 @@ import (
 type PipelineOrchestrator struct {
 	ctrl     *gomock.Controller
 	recorder *PipelineOrchestratorMockRecorder
+	isgomock struct{}
 }
 
 // PipelineOrchestratorMockRecorder is the mock recorder for PipelineOrchestrator.
@@ -41,18 +42,18 @@ func (m *PipelineOrchestrator) EXPECT() *PipelineOrchestratorMockRecorder {
 }
 
 // Create mocks base method.
-func (m *PipelineOrchestrator) Create(arg0 context.Context, arg1 pipeline.Config) (*pipeline.Instance, error) {
+func (m *PipelineOrchestrator) Create(ctx context.Context, cfg pipeline.Config) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1)
+	ret := m.ctrl.Call(m, "Create", ctx, cfg)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *PipelineOrchestratorMockRecorder) Create(arg0, arg1 any) *PipelineOrchestratorCreateCall {
+func (mr *PipelineOrchestratorMockRecorder) Create(ctx, cfg any) *PipelineOrchestratorCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineOrchestrator)(nil).Create), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*PipelineOrchestrator)(nil).Create), ctx, cfg)
 	return &PipelineOrchestratorCreateCall{Call: call}
 }
 
@@ -80,17 +81,17 @@ func (c *PipelineOrchestratorCreateCall) DoAndReturn(f func(context.Context, pip
 }
 
 // Delete mocks base method.
-func (m *PipelineOrchestrator) Delete(arg0 context.Context, arg1 string) error {
+func (m *PipelineOrchestrator) Delete(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *PipelineOrchestratorMockRecorder) Delete(arg0, arg1 any) *PipelineOrchestratorDeleteCall {
+func (mr *PipelineOrchestratorMockRecorder) Delete(ctx, id any) *PipelineOrchestratorDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineOrchestrator)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*PipelineOrchestrator)(nil).Delete), ctx, id)
 	return &PipelineOrchestratorDeleteCall{Call: call}
 }
 
@@ -118,18 +119,18 @@ func (c *PipelineOrchestratorDeleteCall) DoAndReturn(f func(context.Context, str
 }
 
 // Get mocks base method.
-func (m *PipelineOrchestrator) Get(arg0 context.Context, arg1 string) (*pipeline.Instance, error) {
+func (m *PipelineOrchestrator) Get(ctx context.Context, id string) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *PipelineOrchestratorMockRecorder) Get(arg0, arg1 any) *PipelineOrchestratorGetCall {
+func (mr *PipelineOrchestratorMockRecorder) Get(ctx, id any) *PipelineOrchestratorGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineOrchestrator)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*PipelineOrchestrator)(nil).Get), ctx, id)
 	return &PipelineOrchestratorGetCall{Call: call}
 }
 
@@ -157,17 +158,17 @@ func (c *PipelineOrchestratorGetCall) DoAndReturn(f func(context.Context, string
 }
 
 // List mocks base method.
-func (m *PipelineOrchestrator) List(arg0 context.Context) map[string]*pipeline.Instance {
+func (m *PipelineOrchestrator) List(ctx context.Context) map[string]*pipeline.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*pipeline.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *PipelineOrchestratorMockRecorder) List(arg0 any) *PipelineOrchestratorListCall {
+func (mr *PipelineOrchestratorMockRecorder) List(ctx any) *PipelineOrchestratorListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineOrchestrator)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*PipelineOrchestrator)(nil).List), ctx)
 	return &PipelineOrchestratorListCall{Call: call}
 }
 
@@ -195,17 +196,17 @@ func (c *PipelineOrchestratorListCall) DoAndReturn(f func(context.Context) map[s
 }
 
 // Start mocks base method.
-func (m *PipelineOrchestrator) Start(arg0 context.Context, arg1 string) error {
+func (m *PipelineOrchestrator) Start(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Start", arg0, arg1)
+	ret := m.ctrl.Call(m, "Start", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Start indicates an expected call of Start.
-func (mr *PipelineOrchestratorMockRecorder) Start(arg0, arg1 any) *PipelineOrchestratorStartCall {
+func (mr *PipelineOrchestratorMockRecorder) Start(ctx, id any) *PipelineOrchestratorStartCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*PipelineOrchestrator)(nil).Start), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*PipelineOrchestrator)(nil).Start), ctx, id)
 	return &PipelineOrchestratorStartCall{Call: call}
 }
 
@@ -233,17 +234,17 @@ func (c *PipelineOrchestratorStartCall) DoAndReturn(f func(context.Context, stri
 }
 
 // Stop mocks base method.
-func (m *PipelineOrchestrator) Stop(arg0 context.Context, arg1 string, arg2 bool) error {
+func (m *PipelineOrchestrator) Stop(ctx context.Context, id string, force bool) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Stop", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Stop", ctx, id, force)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Stop indicates an expected call of Stop.
-func (mr *PipelineOrchestratorMockRecorder) Stop(arg0, arg1, arg2 any) *PipelineOrchestratorStopCall {
+func (mr *PipelineOrchestratorMockRecorder) Stop(ctx, id, force any) *PipelineOrchestratorStopCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*PipelineOrchestrator)(nil).Stop), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*PipelineOrchestrator)(nil).Stop), ctx, id, force)
 	return &PipelineOrchestratorStopCall{Call: call}
 }
 
@@ -271,18 +272,18 @@ func (c *PipelineOrchestratorStopCall) DoAndReturn(f func(context.Context, strin
 }
 
 // Update mocks base method.
-func (m *PipelineOrchestrator) Update(arg0 context.Context, arg1 string, arg2 pipeline.Config) (*pipeline.Instance, error) {
+func (m *PipelineOrchestrator) Update(ctx context.Context, id string, cfg pipeline.Config) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, cfg)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *PipelineOrchestratorMockRecorder) Update(arg0, arg1, arg2 any) *PipelineOrchestratorUpdateCall {
+func (mr *PipelineOrchestratorMockRecorder) Update(ctx, id, cfg any) *PipelineOrchestratorUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineOrchestrator)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*PipelineOrchestrator)(nil).Update), ctx, id, cfg)
 	return &PipelineOrchestratorUpdateCall{Call: call}
 }
 
@@ -310,18 +311,18 @@ func (c *PipelineOrchestratorUpdateCall) DoAndReturn(f func(context.Context, str
 }
 
 // UpdateDLQ mocks base method.
-func (m *PipelineOrchestrator) UpdateDLQ(arg0 context.Context, arg1 string, arg2 pipeline.DLQ) (*pipeline.Instance, error) {
+func (m *PipelineOrchestrator) UpdateDLQ(ctx context.Context, id string, dlq pipeline.DLQ) (*pipeline.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateDLQ", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "UpdateDLQ", ctx, id, dlq)
 	ret0, _ := ret[0].(*pipeline.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // UpdateDLQ indicates an expected call of UpdateDLQ.
-func (mr *PipelineOrchestratorMockRecorder) UpdateDLQ(arg0, arg1, arg2 any) *PipelineOrchestratorUpdateDLQCall {
+func (mr *PipelineOrchestratorMockRecorder) UpdateDLQ(ctx, id, dlq any) *PipelineOrchestratorUpdateDLQCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineOrchestrator)(nil).UpdateDLQ), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQ", reflect.TypeOf((*PipelineOrchestrator)(nil).UpdateDLQ), ctx, id, dlq)
 	return &PipelineOrchestratorUpdateDLQCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/processor.go b/pkg/web/api/mock/processor.go
index e08e6694d..40d77fb4c 100644
--- a/pkg/web/api/mock/processor.go
+++ b/pkg/web/api/mock/processor.go
@@ -22,6 +22,7 @@ import (
 type ProcessorOrchestrator struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorOrchestratorMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorOrchestratorMockRecorder is the mock recorder for ProcessorOrchestrator.
@@ -42,18 +43,18 @@ func (m *ProcessorOrchestrator) EXPECT() *ProcessorOrchestratorMockRecorder {
 }
 
 // Create mocks base method.
-func (m *ProcessorOrchestrator) Create(arg0 context.Context, arg1 string, arg2 processor.Parent, arg3 processor.Config, arg4 string) (*processor.Instance, error) {
+func (m *ProcessorOrchestrator) Create(ctx context.Context, procType string, parent processor.Parent, cfg processor.Config, condition string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4)
+	ret := m.ctrl.Call(m, "Create", ctx, procType, parent, cfg, condition)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Create indicates an expected call of Create.
-func (mr *ProcessorOrchestratorMockRecorder) Create(arg0, arg1, arg2, arg3, arg4 any) *ProcessorOrchestratorCreateCall {
+func (mr *ProcessorOrchestratorMockRecorder) Create(ctx, procType, parent, cfg, condition any) *ProcessorOrchestratorCreateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorOrchestrator)(nil).Create), arg0, arg1, arg2, arg3, arg4)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*ProcessorOrchestrator)(nil).Create), ctx, procType, parent, cfg, condition)
 	return &ProcessorOrchestratorCreateCall{Call: call}
 }
 
@@ -81,17 +82,17 @@ func (c *ProcessorOrchestratorCreateCall) DoAndReturn(f func(context.Context, st
 }
 
 // Delete mocks base method.
-func (m *ProcessorOrchestrator) Delete(arg0 context.Context, arg1 string) error {
+func (m *ProcessorOrchestrator) Delete(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *ProcessorOrchestratorMockRecorder) Delete(arg0, arg1 any) *ProcessorOrchestratorDeleteCall {
+func (mr *ProcessorOrchestratorMockRecorder) Delete(ctx, id any) *ProcessorOrchestratorDeleteCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorOrchestrator)(nil).Delete), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*ProcessorOrchestrator)(nil).Delete), ctx, id)
 	return &ProcessorOrchestratorDeleteCall{Call: call}
 }
 
@@ -119,18 +120,18 @@ func (c *ProcessorOrchestratorDeleteCall) DoAndReturn(f func(context.Context, st
 }
 
 // Get mocks base method.
-func (m *ProcessorOrchestrator) Get(arg0 context.Context, arg1 string) (*processor.Instance, error) {
+func (m *ProcessorOrchestrator) Get(ctx context.Context, id string) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "Get", ctx, id)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get.
-func (mr *ProcessorOrchestratorMockRecorder) Get(arg0, arg1 any) *ProcessorOrchestratorGetCall {
+func (mr *ProcessorOrchestratorMockRecorder) Get(ctx, id any) *ProcessorOrchestratorGetCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorOrchestrator)(nil).Get), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*ProcessorOrchestrator)(nil).Get), ctx, id)
 	return &ProcessorOrchestratorGetCall{Call: call}
 }
 
@@ -158,18 +159,18 @@ func (c *ProcessorOrchestratorGetCall) DoAndReturn(f func(context.Context, strin
 }
 
 // InspectIn mocks base method.
-func (m *ProcessorOrchestrator) InspectIn(arg0 context.Context, arg1 string) (*inspector.Session, error) {
+func (m *ProcessorOrchestrator) InspectIn(ctx context.Context, id string) (*inspector.Session, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "InspectIn", arg0, arg1)
+	ret := m.ctrl.Call(m, "InspectIn", ctx, id)
 	ret0, _ := ret[0].(*inspector.Session)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // InspectIn indicates an expected call of InspectIn.
-func (mr *ProcessorOrchestratorMockRecorder) InspectIn(arg0, arg1 any) *ProcessorOrchestratorInspectInCall {
+func (mr *ProcessorOrchestratorMockRecorder) InspectIn(ctx, id any) *ProcessorOrchestratorInspectInCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectIn", reflect.TypeOf((*ProcessorOrchestrator)(nil).InspectIn), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectIn", reflect.TypeOf((*ProcessorOrchestrator)(nil).InspectIn), ctx, id)
 	return &ProcessorOrchestratorInspectInCall{Call: call}
 }
 
@@ -197,18 +198,18 @@ func (c *ProcessorOrchestratorInspectInCall) DoAndReturn(f func(context.Context,
 }
 
 // InspectOut mocks base method.
-func (m *ProcessorOrchestrator) InspectOut(arg0 context.Context, arg1 string) (*inspector.Session, error) {
+func (m *ProcessorOrchestrator) InspectOut(ctx context.Context, id string) (*inspector.Session, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "InspectOut", arg0, arg1)
+	ret := m.ctrl.Call(m, "InspectOut", ctx, id)
 	ret0, _ := ret[0].(*inspector.Session)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // InspectOut indicates an expected call of InspectOut.
-func (mr *ProcessorOrchestratorMockRecorder) InspectOut(arg0, arg1 any) *ProcessorOrchestratorInspectOutCall {
+func (mr *ProcessorOrchestratorMockRecorder) InspectOut(ctx, id any) *ProcessorOrchestratorInspectOutCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectOut", reflect.TypeOf((*ProcessorOrchestrator)(nil).InspectOut), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectOut", reflect.TypeOf((*ProcessorOrchestrator)(nil).InspectOut), ctx, id)
 	return &ProcessorOrchestratorInspectOutCall{Call: call}
 }
 
@@ -236,17 +237,17 @@ func (c *ProcessorOrchestratorInspectOutCall) DoAndReturn(f func(context.Context
 }
 
 // List mocks base method.
-func (m *ProcessorOrchestrator) List(arg0 context.Context) map[string]*processor.Instance {
+func (m *ProcessorOrchestrator) List(ctx context.Context) map[string]*processor.Instance {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]*processor.Instance)
 	return ret0
 }
 
 // List indicates an expected call of List.
-func (mr *ProcessorOrchestratorMockRecorder) List(arg0 any) *ProcessorOrchestratorListCall {
+func (mr *ProcessorOrchestratorMockRecorder) List(ctx any) *ProcessorOrchestratorListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorOrchestrator)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorOrchestrator)(nil).List), ctx)
 	return &ProcessorOrchestratorListCall{Call: call}
 }
 
@@ -274,18 +275,18 @@ func (c *ProcessorOrchestratorListCall) DoAndReturn(f func(context.Context) map[
 }
 
 // Update mocks base method.
-func (m *ProcessorOrchestrator) Update(arg0 context.Context, arg1 string, arg2 processor.Config) (*processor.Instance, error) {
+func (m *ProcessorOrchestrator) Update(ctx context.Context, id string, cfg processor.Config) (*processor.Instance, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Update", ctx, id, cfg)
 	ret0, _ := ret[0].(*processor.Instance)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Update indicates an expected call of Update.
-func (mr *ProcessorOrchestratorMockRecorder) Update(arg0, arg1, arg2 any) *ProcessorOrchestratorUpdateCall {
+func (mr *ProcessorOrchestratorMockRecorder) Update(ctx, id, cfg any) *ProcessorOrchestratorUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorOrchestrator)(nil).Update), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*ProcessorOrchestrator)(nil).Update), ctx, id, cfg)
 	return &ProcessorOrchestratorUpdateCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/processor_plugin.go b/pkg/web/api/mock/processor_plugin.go
index 132a10df7..8f1d52de3 100644
--- a/pkg/web/api/mock/processor_plugin.go
+++ b/pkg/web/api/mock/processor_plugin.go
@@ -21,6 +21,7 @@ import (
 type ProcessorPluginOrchestrator struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorPluginOrchestratorMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorPluginOrchestratorMockRecorder is the mock recorder for ProcessorPluginOrchestrator.
@@ -41,18 +42,18 @@ func (m *ProcessorPluginOrchestrator) EXPECT() *ProcessorPluginOrchestratorMockR
 }
 
 // List mocks base method.
-func (m *ProcessorPluginOrchestrator) List(arg0 context.Context) (map[string]sdk.Specification, error) {
+func (m *ProcessorPluginOrchestrator) List(ctx context.Context) (map[string]sdk.Specification, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "List", arg0)
+	ret := m.ctrl.Call(m, "List", ctx)
 	ret0, _ := ret[0].(map[string]sdk.Specification)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // List indicates an expected call of List.
-func (mr *ProcessorPluginOrchestratorMockRecorder) List(arg0 any) *ProcessorPluginOrchestratorListCall {
+func (mr *ProcessorPluginOrchestratorMockRecorder) List(ctx any) *ProcessorPluginOrchestratorListCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorPluginOrchestrator)(nil).List), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*ProcessorPluginOrchestrator)(nil).List), ctx)
 	return &ProcessorPluginOrchestratorListCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/processor_service_in.go b/pkg/web/api/mock/processor_service_in.go
index 9d2d33f9e..46c486a80 100644
--- a/pkg/web/api/mock/processor_service_in.go
+++ b/pkg/web/api/mock/processor_service_in.go
@@ -22,6 +22,7 @@ import (
 type ProcessorService_InspectProcessorInServer struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorService_InspectProcessorInServerMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorService_InspectProcessorInServerMockRecorder is the mock recorder for ProcessorService_InspectProcessorInServer.
@@ -80,17 +81,17 @@ func (c *ProcessorService_InspectProcessorInServerContextCall) DoAndReturn(f fun
 }
 
 // RecvMsg mocks base method.
-func (m *ProcessorService_InspectProcessorInServer) RecvMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RecvMsg", arg0)
+func (m_2 *ProcessorService_InspectProcessorInServer) RecvMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *ProcessorService_InspectProcessorInServerMockRecorder) RecvMsg(arg0 any) *ProcessorService_InspectProcessorInServerRecvMsgCall {
+func (mr *ProcessorService_InspectProcessorInServerMockRecorder) RecvMsg(m any) *ProcessorService_InspectProcessorInServerRecvMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ProcessorService_InspectProcessorInServer)(nil).RecvMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ProcessorService_InspectProcessorInServer)(nil).RecvMsg), m)
 	return &ProcessorService_InspectProcessorInServerRecvMsgCall{Call: call}
 }
 
@@ -194,17 +195,17 @@ func (c *ProcessorService_InspectProcessorInServerSendHeaderCall) DoAndReturn(f
 }
 
 // SendMsg mocks base method.
-func (m *ProcessorService_InspectProcessorInServer) SendMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMsg", arg0)
+func (m_2 *ProcessorService_InspectProcessorInServer) SendMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *ProcessorService_InspectProcessorInServerMockRecorder) SendMsg(arg0 any) *ProcessorService_InspectProcessorInServerSendMsgCall {
+func (mr *ProcessorService_InspectProcessorInServerMockRecorder) SendMsg(m any) *ProcessorService_InspectProcessorInServerSendMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ProcessorService_InspectProcessorInServer)(nil).SendMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ProcessorService_InspectProcessorInServer)(nil).SendMsg), m)
 	return &ProcessorService_InspectProcessorInServerSendMsgCall{Call: call}
 }
 
diff --git a/pkg/web/api/mock/processor_service_out.go b/pkg/web/api/mock/processor_service_out.go
index 87281023b..78b201792 100644
--- a/pkg/web/api/mock/processor_service_out.go
+++ b/pkg/web/api/mock/processor_service_out.go
@@ -22,6 +22,7 @@ import (
 type ProcessorService_InspectProcessorOutServer struct {
 	ctrl     *gomock.Controller
 	recorder *ProcessorService_InspectProcessorOutServerMockRecorder
+	isgomock struct{}
 }
 
 // ProcessorService_InspectProcessorOutServerMockRecorder is the mock recorder for ProcessorService_InspectProcessorOutServer.
@@ -80,17 +81,17 @@ func (c *ProcessorService_InspectProcessorOutServerContextCall) DoAndReturn(f fu
 }
 
 // RecvMsg mocks base method.
-func (m *ProcessorService_InspectProcessorOutServer) RecvMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RecvMsg", arg0)
+func (m_2 *ProcessorService_InspectProcessorOutServer) RecvMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // RecvMsg indicates an expected call of RecvMsg.
-func (mr *ProcessorService_InspectProcessorOutServerMockRecorder) RecvMsg(arg0 any) *ProcessorService_InspectProcessorOutServerRecvMsgCall {
+func (mr *ProcessorService_InspectProcessorOutServerMockRecorder) RecvMsg(m any) *ProcessorService_InspectProcessorOutServerRecvMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ProcessorService_InspectProcessorOutServer)(nil).RecvMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*ProcessorService_InspectProcessorOutServer)(nil).RecvMsg), m)
 	return &ProcessorService_InspectProcessorOutServerRecvMsgCall{Call: call}
 }
 
@@ -194,17 +195,17 @@ func (c *ProcessorService_InspectProcessorOutServerSendHeaderCall) DoAndReturn(f
 }
 
 // SendMsg mocks base method.
-func (m *ProcessorService_InspectProcessorOutServer) SendMsg(arg0 any) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMsg", arg0)
+func (m_2 *ProcessorService_InspectProcessorOutServer) SendMsg(m any) error {
+	m_2.ctrl.T.Helper()
+	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SendMsg indicates an expected call of SendMsg.
-func (mr *ProcessorService_InspectProcessorOutServerMockRecorder) SendMsg(arg0 any) *ProcessorService_InspectProcessorOutServerSendMsgCall {
+func (mr *ProcessorService_InspectProcessorOutServerMockRecorder) SendMsg(m any) *ProcessorService_InspectProcessorOutServerSendMsgCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ProcessorService_InspectProcessorOutServer)(nil).SendMsg), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*ProcessorService_InspectProcessorOutServer)(nil).SendMsg), m)
 	return &ProcessorService_InspectProcessorOutServerSendMsgCall{Call: call}
 }