Implement the Repo maintanence Job configuration design.

Signed-off-by: Xun Jiang <[email protected]>

pkg/cmd/server/server.go

@@ -667,7 +667,7 @@ func (s *server) initRepoManager() error {
 	s.repoLocker = repository.NewRepoLocker()
 	s.repoEnsurer = repository.NewEnsurer(s.mgr.GetClient(), s.logger, s.config.resourceTimeout)
 
-	s.repoManager = repository.NewManager(s.namespace, s.mgr.GetClient(), s.repoLocker, s.repoEnsurer, s.credentialFileStore, s.credentialSecretStore, s.config.maintenanceCfg, s.logger)
+	s.repoManager = repository.NewManager(s.namespace, s.mgr.GetClient(), s.crClient, s.repoLocker, s.repoEnsurer, s.credentialFileStore, s.credentialSecretStore, s.config.maintenanceCfg, s.logger)
 
 	return nil
 }

pkg/repository/maintenance.go

@@ -55,6 +55,7 @@ type MaintenanceConfig struct {
 	MemLimit                 string
 	LogLevelFlag             *logging.LevelFlag
 	FormatFlag               *logging.FormatFlag
+	Affinity                 *v1.Affinity
 }
 
 func generateJobName(repo string) string {
@@ -156,9 +157,11 @@ func buildMaintenanceJob(m MaintenanceConfig, param provider.RepoParam, cli clie
 		},
 	}
 
-	if affinity := veleroutil.GetAffinityFromVeleroServer(deployment); affinity != nil {
-		job.Spec.Template.Spec.Affinity = affinity
+	affinity := m.Affinity
+	if affinity == nil {
+		affinity = veleroutil.GetAffinityFromVeleroServer(deployment)
 	}
+	job.Spec.Template.Spec.Affinity = affinity
 
 	if tolerations := veleroutil.GetTolerationsFromVeleroServer(deployment); tolerations != nil {
 		job.Spec.Template.Spec.Tolerations = tolerations

pkg/repository/manager.go

@@ -18,11 +18,16 @@ package repository
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"time"
 
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
+	v1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/vmware-tanzu/velero/internal/credentials"
@@ -102,10 +107,99 @@ type manager struct {
 	log            logrus.FieldLogger
 }
 
+type MaintenanceConfigMap map[string]Configs
+
+type Configs struct {
+	// LoadAffinity is the config for repository maintenance job load affinity.
+	LoadAffinity []*LoadAffinity `json:"loadAffinity,omitempty"`
+
+	KeepLatestJobsCount int    `json:"keepLatestJobsCount,omitempty"`
+	CPURequest          string `json:"cpuRequest,omitempty"`
+	MemRequest          string `json:"memRequest,omitempty"`
+	CPULimit            string `json:"cpuLimit,omitempty"`
+	MemLimit            string `json:"memLimit,omitempty"`
+}
+
+type LoadAffinity struct {
+	// NodeSelector specifies the label selector to match nodes
+	NodeSelector metav1.LabelSelector `json:"nodeSelector"`
+}
+
+func GetConfigs(ctx context.Context, namespace string, cli client.Client) (MaintenanceConfigMap, error) {
+	var cm v1.ConfigMap
+	err := cli.Get(ctx, types.NamespacedName{Namespace: namespace, Name: "repo-maintenance-job-config"}, &cm)
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			return nil, nil
+		} else {
+			return nil, errors.Wrapf(err, "error to get node agent configs %s", "repo-maintenance-job-config")
+		}
+	}
+
+	if cm.Data == nil {
+		return nil, errors.Errorf("data is not available in config map %s", "repo-maintenance-job-config")
+	}
+
+	jsonString := ""
+	for _, v := range cm.Data {
+		jsonString = v
+	}
+
+	var configs MaintenanceConfigMap
+	err = json.Unmarshal([]byte(jsonString), &configs)
+	if err != nil {
+		return nil, errors.Wrapf(err, "error to unmarshal configs from %s", "repo-maintenance-job-config")
+	}
+
+	return configs, nil
+}
+
+/*
+func toSystemAffinity(loadAffinity *nodeagent.LoadAffinity) *v1.Affinity {
+	if loadAffinity == nil {
+		return nil
+	}
+
+	requirements := []v1.NodeSelectorRequirement{}
+	for k, v := range loadAffinity.NodeSelector.MatchLabels {
+		requirements = append(requirements, v1.NodeSelectorRequirement{
+			Key:      k,
+			Values:   []string{v},
+			Operator: v1.NodeSelectorOpIn,
+		})
+	}
+
+	for _, exp := range loadAffinity.NodeSelector.MatchExpressions {
+		requirements = append(requirements, v1.NodeSelectorRequirement{
+			Key:      exp.Key,
+			Values:   exp.Values,
+			Operator: v1.NodeSelectorOperator(exp.Operator),
+		})
+	}
+
+	if len(requirements) == 0 {
+		return nil
+	}
+
+	return &v1.Affinity{
+		NodeAffinity: &v1.NodeAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
+				NodeSelectorTerms: []v1.NodeSelectorTerm{
+					{
+						MatchExpressions: requirements,
+					},
+				},
+			},
+		},
+	}
+}
+*/
+
 // NewManager create a new repository manager.
 func NewManager(
 	namespace string,
 	client client.Client,
+	crClient client.Client,
 	repoLocker *RepoLocker,
 	repoEnsurer *Ensurer,
 	credentialFileStore credentials.FileStore,
@@ -124,6 +218,12 @@ func NewManager(
 		log:            log,
 	}
 
+	config, err := GetConfigs(context.Background(), namespace, crClient)
+	if err != nil {
+		log.Info("Cannot find the repo-maintenance-job-config ConfigMap: %s", err.Error())
+	}
+	fmt.Printf("The loaded ConfigMap content is %+v\n", config)
+
 	mgr.providers[velerov1api.BackupRepositoryTypeRestic] = provider.NewResticRepositoryProvider(credentialFileStore, mgr.fileSystem, mgr.log)
 	mgr.providers[velerov1api.BackupRepositoryTypeKopia] = provider.NewUnifiedRepoProvider(credentials.CredentialGetter{
 		FromFile:   credentialFileStore,

pkg/repository/manager_test.go

@@ -28,7 +28,7 @@ import (
 
 func TestGetRepositoryProvider(t *testing.T) {
 	var fakeClient kbclient.Client
-	mgr := NewManager("", fakeClient, nil, nil, nil, nil, MaintenanceConfig{}, nil).(*manager)
+	mgr := NewManager("", fakeClient, nil, nil, nil, nil, nil, MaintenanceConfig{}, nil).(*manager)
 	repo := &velerov1.BackupRepository{}
 
 	// empty repository type