refactoring manifest repository

internal/repository/kyma.go

@@ -17,7 +17,7 @@ func NewKymaRepository(client client.Client) *KymaRepository {
 	return &KymaRepository{Client: client}
 }
 
-func (r *KymaRepository) GetKyma(ctx context.Context, namespacedName client.ObjectKey) (*v1beta2.Kyma, error) {
+func (r *KymaRepository) Get(ctx context.Context, namespacedName client.ObjectKey) (*v1beta2.Kyma, error) {
 	kyma := &v1beta2.Kyma{}
 	if err := r.Client.Get(ctx, namespacedName, kyma); err != nil {
 		return nil, fmt.Errorf("failed to get Kyma: %w", err)

internal/repository/manifest.go

@@ -8,62 +8,38 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 
-	"github.com/kyma-project/lifecycle-manager/api/shared"
 	"github.com/kyma-project/lifecycle-manager/api/v1beta2"
-	"github.com/kyma-project/lifecycle-manager/internal/descriptor/provider"
 	"github.com/kyma-project/lifecycle-manager/pkg/log"
 )
 
 type ManifestRepository struct {
-	Client             client.Client
-	DescriptorProvider *provider.CachedDescriptorProvider
+	Client client.Client
 }
 
 func NewManifestRepository(client client.Client,
-	descriptorProvider *provider.CachedDescriptorProvider,
 ) *ManifestRepository {
 	return &ManifestRepository{
-		Client:             client,
-		DescriptorProvider: descriptorProvider,
+		Client: client,
 	}
 }
 
-func (r *ManifestRepository) GetMandatoryManifests(ctx context.Context,
-	template *v1beta2.ModuleTemplate,
-) ([]v1beta2.Manifest, error) {
-	manifests := &v1beta2.ManifestList{}
-	descriptor, err := r.DescriptorProvider.GetDescriptor(template)
-	if err != nil {
-		return nil, fmt.Errorf("not able to get descriptor from template: %w", err)
-	}
-	if err := r.Client.List(ctx, manifests, &client.ListOptions{
-		Namespace:     template.Namespace,
-		LabelSelector: k8slabels.SelectorFromSet(k8slabels.Set{shared.IsMandatoryModule: "true"}),
-	}); client.IgnoreNotFound(err) != nil {
-		return nil, fmt.Errorf("not able to list mandatory module manifests: %w", err)
-	}
-
-	return filterManifestsByAnnotation(manifests.Items, shared.FQDN, descriptor.GetName()), nil
-}
-
-func (r *ManifestRepository) RemoveManifests(ctx context.Context, manifests []v1beta2.Manifest) error {
+func (m *ManifestRepository) RemoveManifests(ctx context.Context, manifests []v1beta2.Manifest) error {
 	for _, manifest := range manifests {
-		if err := r.Client.Delete(ctx, &manifest); err != nil {
+		if err := m.Client.Delete(ctx, &manifest); err != nil {
 			return fmt.Errorf("not able to delete manifest %s/%s: %w", manifest.Namespace, manifest.Name, err)
 		}
 	}
 	logf.FromContext(ctx).V(log.DebugLevel).Info("Marked all Manifests for deletion")
 	return nil
 }
 
-func filterManifestsByAnnotation(manifests []v1beta2.Manifest,
-	annotationKey, annotationValue string,
-) []v1beta2.Manifest {
-	filteredManifests := make([]v1beta2.Manifest, 0)
-	for _, manifest := range manifests {
-		if manifest.Annotations[annotationKey] == annotationValue {
-			filteredManifests = append(filteredManifests, manifest)
-		}
+func (m *ManifestRepository) ListByLabel(ctx context.Context,
+	labelSelector k8slabels.Selector,
+) (*v1beta2.ManifestList, error) {
+	manifestList := &v1beta2.ManifestList{}
+	if err := m.Client.List(ctx, manifestList,
+		&client.ListOptions{LabelSelector: labelSelector}); err != nil {
+		return nil, fmt.Errorf("could not list ManifestList: %w", err)
 	}
-	return filteredManifests
+	return manifestList, nil
 }

internal/repository/module_template.go

@@ -40,10 +40,10 @@ func (m *ModuleTemplateRepository) Update(ctx context.Context,
 func (m *ModuleTemplateRepository) ListByLabel(ctx context.Context,
 	labelSelector k8slabels.Selector,
 ) (*v1beta2.ModuleTemplateList, error) {
-	mandatoryModuleTemplateList := &v1beta2.ModuleTemplateList{}
-	if err := m.Client.List(ctx, mandatoryModuleTemplateList,
+	moduleTemplateList := &v1beta2.ModuleTemplateList{}
+	if err := m.Client.List(ctx, moduleTemplateList,
 		&client.ListOptions{LabelSelector: labelSelector}); err != nil {
 		return nil, fmt.Errorf("could not list ModuleTemplates: %w", err)
 	}
-	return mandatoryModuleTemplateList, nil
+	return moduleTemplateList, nil
 }

internal/service/kyma.go

@@ -10,15 +10,15 @@ import (
 )
 
 type KymaService struct {
-	KymaRepository *repository.KymaRepository
+	kymaRepository *repository.KymaRepository
 }
 
 func NewKymaService(client client.Client) *KymaService {
 	return &KymaService{
-		KymaRepository: repository.NewKymaRepository(client),
+		kymaRepository: repository.NewKymaRepository(client),
 	}
 }
 
 func (s *KymaService) GetKyma(ctx context.Context, namespacedName client.ObjectKey) (*v1beta2.Kyma, error) {
-	return s.KymaRepository.GetKyma(ctx, namespacedName)
+	return s.kymaRepository.Get(ctx, namespacedName)
 }

internal/service/mandatory_module_deletion.go

@@ -12,21 +12,23 @@ import (
 )
 
 type MandatoryModuleDeletionService struct {
-	ManifestRepository *repository.ManifestRepository
+	manifestRepository *repository.ManifestRepository
+	manifestService    *ManifestService
 }
 
 func NewMandatoryModuleDeletionService(client client.Client,
 	descriptorProvider *provider.CachedDescriptorProvider,
 ) *MandatoryModuleDeletionService {
 	return &MandatoryModuleDeletionService{
-		ManifestRepository: repository.NewManifestRepository(client, descriptorProvider),
+		manifestRepository: repository.NewManifestRepository(client),
+		manifestService:    NewManifestService(client, descriptorProvider),
 	}
 }
 
 func (s *MandatoryModuleDeletionService) DeleteMandatoryModules(ctx context.Context,
 	template *v1beta2.ModuleTemplate,
 ) (bool, error) {
-	manifests, err := s.ManifestRepository.GetMandatoryManifests(ctx, template)
+	manifests, err := s.manifestService.GetMandatoryManifests(ctx, template)
 	if err != nil {
 		return false, fmt.Errorf("failed to get MandatoryModuleManifests: %w", err)
 	}
@@ -35,7 +37,7 @@ func (s *MandatoryModuleDeletionService) DeleteMandatoryModules(ctx context.Cont
 		return true, nil
 	}
 
-	if err := s.ManifestRepository.RemoveManifests(ctx, manifests); err != nil {
+	if err := s.manifestRepository.RemoveManifests(ctx, manifests); err != nil {
 		return false, fmt.Errorf("failed to remove MandatoryModule Manifest: %w", err)
 	}
 

internal/service/manifest.go

@@ -1,3 +1,56 @@
 package service
 
-type ManifestService struct{}
+import (
+	"context"
+	"fmt"
+
+	k8slabels "k8s.io/apimachinery/pkg/labels"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/kyma-project/lifecycle-manager/api/shared"
+	"github.com/kyma-project/lifecycle-manager/api/v1beta2"
+	"github.com/kyma-project/lifecycle-manager/internal/descriptor/provider"
+	"github.com/kyma-project/lifecycle-manager/internal/repository"
+)
+
+type ManifestService struct {
+	descriptorProvider *provider.CachedDescriptorProvider
+	manifestRepository *repository.ManifestRepository
+}
+
+func NewManifestService(client client.Client, descriptorProvider *provider.CachedDescriptorProvider) *ManifestService {
+	return &ManifestService{
+		descriptorProvider: descriptorProvider,
+		manifestRepository: repository.NewManifestRepository(client),
+	}
+}
+
+func (r *ManifestService) GetMandatoryManifests(ctx context.Context,
+	template *v1beta2.ModuleTemplate,
+) ([]v1beta2.Manifest, error) {
+	descriptor, err := r.descriptorProvider.GetDescriptor(template)
+	if err != nil {
+		return nil, fmt.Errorf("not able to get descriptor from template: %w", err)
+	}
+	manifests, err := r.manifestRepository.ListByLabel(ctx, k8slabels.SelectorFromSet(k8slabels.Set{
+		shared.IsMandatoryModule: "true",
+	}))
+
+	if client.IgnoreNotFound(err) != nil {
+		return nil, fmt.Errorf("not able to list mandatory module manifests: %w", err)
+	}
+
+	return filterManifestsByAnnotation(manifests.Items, shared.FQDN, descriptor.GetName()), nil
+}
+
+func filterManifestsByAnnotation(manifests []v1beta2.Manifest,
+	annotationKey, annotationValue string,
+) []v1beta2.Manifest {
+	filteredManifests := make([]v1beta2.Manifest, 0)
+	for _, manifest := range manifests {
+		if manifest.Annotations[annotationKey] == annotationValue {
+			filteredManifests = append(filteredManifests, manifest)
+		}
+	}
+	return filteredManifests
+}