get only clustersync and clubing to clusterManager interface

cmd/aro/rp.go

@@ -159,7 +159,6 @@ func rp(ctx context.Context, log, audit *logrus.Entry) error {
 		return err
 	}
 	hiveClusterManager, err := hive.NewFromEnv(ctx, log, _env)
-	syncSetResourceManager, err := hive.NewClusterSyncFromEnv(ctx, log, _env)
 	if err != nil {
 		return err
 	}
@@ -171,7 +170,7 @@ func rp(ctx context.Context, log, audit *logrus.Entry) error {
 		WithPlatformWorkloadIdentityRoleSets(dbPlatformWorkloadIdentityRoleSets).
 		WithSubscriptions(dbSubscriptions)
 
-	f, err := frontend.NewFrontend(ctx, audit, log.WithField("component", "frontend"), _env, dbg, api.APIs, metrics, clusterm, feAead, hiveClusterManager, syncSetResourceManager, adminactions.NewKubeActions, adminactions.NewAzureActions, adminactions.NewAppLensActions, clusterdata.NewParallelEnricher(metrics, _env))
+	f, err := frontend.NewFrontend(ctx, audit, log.WithField("component", "frontend"), _env, dbg, api.APIs, metrics, clusterm, feAead, hiveClusterManager, adminactions.NewKubeActions, adminactions.NewAzureActions, adminactions.NewAppLensActions, clusterdata.NewParallelEnricher(metrics, _env))
 	if err != nil {
 		return err
 	}

pkg/frontend/admin_hive_clusterdeployment_get_test.go

@@ -89,9 +89,9 @@ func Test_getAdminHiveClusterDeployment(t *testing.T) {
 			if tt.hiveEnabled {
 				clusterManager := mock_hive.NewMockClusterManager(controller)
 				clusterManager.EXPECT().GetClusterDeployment(gomock.Any(), gomock.Any()).Return(&clusterDeployment, nil).Times(tt.expectedGetClusterDeploymentCallCount)
-				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, clusterManager, nil, nil, nil, nil, nil)
+				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, clusterManager, nil, nil, nil, nil)
 			} else {
-				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			}
 
 			if err != nil {

pkg/frontend/admin_hive_syncset_resources.go

@@ -32,7 +32,7 @@ func (f *frontend) getAdminHiveSyncsetResources(w http.ResponseWriter, r *http.R
 
 func (f *frontend) _getAdminHiveSyncsetResources(ctx context.Context, namespace string) ([]byte, error) {
 	// we have to check if the frontend has a valid clustermanager since hive is not everywhere.
-	if f.syncSetResourceManager == nil {
+	if f.hiveClusterManager == nil {
 		return nil, api.NewCloudError(http.StatusInternalServerError, api.CloudErrorCodeInternalServerError, "", "hive is not enabled")
 	}
 
@@ -50,7 +50,7 @@ func (f *frontend) _getAdminHiveSyncsetResources(ctx context.Context, namespace
 		return nil, api.NewCloudError(http.StatusNoContent, api.CloudErrorCodeResourceNotFound, "", "cluster is not managed by hive")
 	}
 
-	cd, err := f.syncSetResourceManager.GetSyncSetResources(ctx, doc)
+	cd, err := f.hiveClusterManager.GetSyncSetResources(ctx, doc)
 	if err != nil {
 		return nil, api.NewCloudError(http.StatusNotFound, api.CloudErrorCodeNotFound, "", "cluster deployment not found")
 	}

pkg/frontend/admin_hive_syncset_resources_test.go

@@ -33,7 +33,7 @@ func TestGetAdminHiveSyncsetResources(t *testing.T) {
 		name           string
 		namespace      string
 		hiveEnabled    bool
-		mocks          func(*test, *mock_hive.MockSyncSetResourceManager)
+		mocks          func(*test, *mock_hive.MockClusterManager)
 		wantStatusCode int
 		wantResponse   []byte
 		wantError      string
@@ -44,15 +44,15 @@ func TestGetAdminHiveSyncsetResources(t *testing.T) {
 			name:           "Cluster SyncSets must be namespaced",
 			namespace:      "",
 			hiveEnabled:    true,
-			mocks:          func(tt *test, s *mock_hive.MockSyncSetResourceManager) {},
+			mocks:          func(tt *test, s *mock_hive.MockClusterManager) {},
 			wantStatusCode: http.StatusNotFound,
 			wantError:      "404: NotFound: : cluster not found",
 		},
 		{
 			name:      "List ClusterSync resources successfully",
 			namespace: "hive",
 			wantError: "",
-			mocks: func(tt *test, s *mock_hive.MockSyncSetResourceManager) {
+			mocks: func(tt *test, s *mock_hive.MockClusterManager) {
 				s.EXPECT().
 					GetSyncSetResources(gomock.Any(), gomock.Any()).
 					Return(&clusterSyncsetTest, nil).Times(1)
@@ -76,11 +76,11 @@ func TestGetAdminHiveSyncsetResources(t *testing.T) {
 			var f *frontend
 			var err error
 			if tt.hiveEnabled {
-				s := mock_hive.NewMockSyncSetResourceManager(ti.controller)
+				s := mock_hive.NewMockClusterManager(ti.controller) //NewMockSyncSetResourceManager(ti.controller)
 				tt.mocks(tt, s)
-				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, s, nil, nil, nil, nil)
+				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			} else {
-				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+				f, err = NewFrontend(ctx, ti.audit, ti.log, _env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			}
 			if err != nil {
 				t.Fatal(err)

pkg/frontend/admin_openshiftcluster_approvecsr_test.go

@@ -91,7 +91,7 @@ func TestAdminApproveCSR(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 

pkg/frontend/admin_openshiftcluster_cordonnode_test.go

@@ -152,7 +152,7 @@ func TestAdminCordonUncordonNode(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 

pkg/frontend/admin_openshiftcluster_delete_managedresource_test.go

@@ -113,7 +113,7 @@ func TestAdminDeleteManagedResource(t *testing.T) {
 			a := mock_adminactions.NewMockAzureActions(ti.controller)
 			tt.mocks(tt, a)
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 

pkg/frontend/admin_openshiftcluster_drainnode_test.go

@@ -84,7 +84,7 @@ func TestAdminDrainNode(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 

pkg/frontend/admin_openshiftcluster_etcdcertificaterenew_test.go

@@ -537,7 +537,6 @@ func TestAdminEtcdCertificateRenew(t *testing.T) {
 				&noop.Noop{},
 				nil,
 				nil,
-				nil,
 				func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 					return k, nil
 				},
@@ -752,7 +751,6 @@ func TestAdminEtcdCertificateRecovery(t *testing.T) {
 				&noop.Noop{},
 				nil,
 				nil,
-				nil,
 				func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 					return k, nil
 				},

pkg/frontend/admin_openshiftcluster_etcdrecovery_test.go

@@ -168,7 +168,6 @@ func TestAdminEtcdRecovery(t *testing.T) {
 				&noop.Noop{},
 				nil,
 				nil,
-				nil,
 				kubeActionsFactory,
 				nil,
 				nil,

pkg/frontend/admin_openshiftcluster_kubernetesobjects_test.go

@@ -262,7 +262,7 @@ func TestAdminKubernetesObjectsGetAndDelete(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 			if err != nil {
@@ -411,7 +411,7 @@ func TestAdminPostKubernetesObjects(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 			if err != nil {

pkg/frontend/admin_openshiftcluster_kubernetespods_logs_test.go

@@ -125,7 +125,7 @@ func TestAdminKubernetesGetPodLogs(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster) (adminactions.KubeActions, error) {
 				return k, nil
 			}, nil, nil, nil)
 			if err != nil {

pkg/frontend/admin_openshiftcluster_list_test.go

@@ -124,7 +124,7 @@ func TestAdminListOpenShiftCluster(t *testing.T) {
 				ti.openShiftClustersClient.SetError(tt.throwsError)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, aead, nil, nil, nil, nil, nil, ti.enricher)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, aead, nil, nil, nil, nil, ti.enricher)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/admin_openshiftcluster_redeployvm_test.go

@@ -84,7 +84,7 @@ func TestAdminRedeployVM(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 

pkg/frontend/admin_openshiftcluster_resources_list_test.go

@@ -93,7 +93,7 @@ func TestAdminListResourcesList(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 			mockResponder := mock_frontend.NewMockStreamResponder(ti.controller)

pkg/frontend/admin_openshiftcluster_startvm_test.go

@@ -84,7 +84,7 @@ func TestAdminStartVM(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 

pkg/frontend/admin_openshiftcluster_stopvm_test.go

@@ -86,7 +86,7 @@ func TestAdminStopVM(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 

pkg/frontend/admin_openshiftcluster_vmresize_test.go

@@ -202,7 +202,7 @@ func TestAdminVMResize(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil,
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil,
 				func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 					return a, nil
 				}, nil, nil)

pkg/frontend/admin_openshiftcluster_vmsizelist_test.go

@@ -136,7 +136,7 @@ func TestAdminListVMSizeList(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AzureActions, error) {
 				return a, nil
 			}, nil, nil)
 

pkg/frontend/admin_openshiftversion_list_test.go

@@ -110,7 +110,7 @@ func TestOpenShiftVersionList(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 
 			if err != nil {
 				t.Fatal(err)

pkg/frontend/admin_openshiftversion_put_test.go

@@ -266,7 +266,7 @@ func TestOpenShiftVersionPut(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/admin_platformworkloadidentityroleset_list_test.go

@@ -258,7 +258,7 @@ func TestPlatformWorkloadIdentityRoleSetList(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 
 			if err != nil {
 				t.Fatal(err)

pkg/frontend/admin_platformworkloadidentityroleset_put_test.go

@@ -757,7 +757,7 @@ func TestPlatformWorkloadIdentityRoleSetPut(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/asyncoperationresult_get_test.go

@@ -136,7 +136,7 @@ func TestGetAsyncOperationResult(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/asyncoperationsstatus_get_test.go

@@ -183,7 +183,7 @@ func TestGetAsyncOperationsStatus(t *testing.T) {
 				ti.asyncOperationsClient.SetError(tt.dbError)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/fixetcd_test.go

@@ -527,7 +527,6 @@ func TestFixEtcd(t *testing.T) {
 				nil,
 				nil,
 				nil,
-				nil,
 				ti.enricher)
 			if err != nil {
 				t.Fatal(err)

pkg/frontend/frontend.go

@@ -81,11 +81,10 @@ type frontend struct {
 
 	aead encryption.AEAD
 
-	hiveClusterManager     hive.ClusterManager
-	syncSetResourceManager hive.SyncSetResourceManager
-	kubeActionsFactory     kubeActionsFactory
-	azureActionsFactory    azureActionsFactory
-	appLensActionsFactory  appLensActionsFactory
+	hiveClusterManager    hive.ClusterManager
+	kubeActionsFactory    kubeActionsFactory
+	azureActionsFactory   azureActionsFactory
+	appLensActionsFactory appLensActionsFactory
 
 	skuValidator       SkuValidator
 	quotaValidator     QuotaValidator
@@ -125,7 +124,6 @@ func NewFrontend(ctx context.Context,
 	clusterm metrics.Emitter,
 	aead encryption.AEAD,
 	hiveClusterManager hive.ClusterManager,
-	syncSetResourceManager hive.SyncSetResourceManager,
 	kubeActionsFactory kubeActionsFactory,
 	azureActionsFactory azureActionsFactory,
 	appLensActionsFactory appLensActionsFactory,
@@ -153,16 +151,15 @@ func NewFrontend(ctx context.Context,
 			AdminAuth: _env.AdminClientAuthorizer(),
 			ArmAuth:   _env.ArmClientAuthorizer(),
 		},
-		dbGroup:                dbGroup,
-		apis:                   apis,
-		m:                      middleware.MetricsMiddleware{Emitter: m},
-		maintenanceMiddleware:  middleware.MaintenanceMiddleware{Emitter: clusterm},
-		aead:                   aead,
-		hiveClusterManager:     hiveClusterManager,
-		syncSetResourceManager: syncSetResourceManager,
-		kubeActionsFactory:     kubeActionsFactory,
-		azureActionsFactory:    azureActionsFactory,
-		appLensActionsFactory:  appLensActionsFactory,
+		dbGroup:               dbGroup,
+		apis:                  apis,
+		m:                     middleware.MetricsMiddleware{Emitter: m},
+		maintenanceMiddleware: middleware.MaintenanceMiddleware{Emitter: clusterm},
+		aead:                  aead,
+		hiveClusterManager:    hiveClusterManager,
+		kubeActionsFactory:    kubeActionsFactory,
+		azureActionsFactory:   azureActionsFactory,
+		appLensActionsFactory: appLensActionsFactory,
 
 		quotaValidator:     quotaValidator{},
 		skuValidator:       skuValidator{},

pkg/frontend/openshiftcluster_applensdetectors_test.go

@@ -97,7 +97,7 @@ func TestAppLensDetectors(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AppLensActions, error) {
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, func(*logrus.Entry, env.Interface, *api.OpenShiftCluster, *api.SubscriptionDocument) (adminactions.AppLensActions, error) {
 				return a, nil
 			}, nil)
 

pkg/frontend/openshiftcluster_delete_test.go

@@ -114,7 +114,7 @@ func TestDeleteOpenShiftCluster(t *testing.T) {
 				ti.subscriptionsClient.SetError(tt.dbError)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, nil)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/frontend/openshiftcluster_get_test.go

@@ -95,7 +95,7 @@ func TestGetOpenShiftCluster(t *testing.T) {
 				ti.openShiftClustersClient.SetError(tt.dbError)
 			}
 
-			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, nil, ti.enricher)
+			f, err := NewFrontend(ctx, ti.audit, ti.log, ti.env, ti.dbGroup, api.APIs, &noop.Noop{}, &noop.Noop{}, nil, nil, nil, nil, nil, ti.enricher)
 			if err != nil {
 				t.Fatal(err)
 			}