repo maintenance job out of repo manager

Signed-off-by: Lyndon-Li <lyonghui@vmware.com>

pkg/cmd/cli/repomantenance/maintenance.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -12,21 +13,25 @@ import (
 	"github.com/spf13/pflag"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/kubernetes"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/vmware-tanzu/velero/internal/credentials"
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	velerocli "github.com/vmware-tanzu/velero/pkg/client"
 	"github.com/vmware-tanzu/velero/pkg/repository"
-	"github.com/vmware-tanzu/velero/pkg/repository/provider"
 	"github.com/vmware-tanzu/velero/pkg/util/filesystem"
 	"github.com/vmware-tanzu/velero/pkg/util/logging"
+
+	repokey "github.com/vmware-tanzu/velero/pkg/repository/keys"
+	repomanager "github.com/vmware-tanzu/velero/pkg/repository/manager"
 )
 
 type Options struct {
 	RepoName              string
 	BackupStorageLocation string
 	RepoType              string
+	ResourceTimeout       time.Duration
 	LogLevelFlag          *logging.LevelFlag
 	FormatFlag            *logging.FormatFlag
 }
@@ -83,39 +88,46 @@ func (o *Options) Run(f velerocli.Factory) {
 	}
 }
 
-func (o *Options) initClient(f velerocli.Factory) (client.Client, error) {
+func (o *Options) initClient(f velerocli.Factory) (client.Client, kubernetes.Interface, error) {
 	scheme := runtime.NewScheme()
 	err := velerov1api.AddToScheme(scheme)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to add velero scheme")
+		return nil, nil, errors.Wrap(err, "failed to add velero scheme")
 	}
 
 	err = v1.AddToScheme(scheme)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to add api core scheme")
+		return nil, nil, errors.Wrap(err, "failed to add api core scheme")
 	}
 
 	config, err := f.ClientConfig()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get client config")
+		return nil, nil, errors.Wrap(err, "failed to get client config")
 	}
 
 	cli, err := client.New(config, client.Options{
 		Scheme: scheme,
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create client")
+		return nil, nil, errors.Wrap(err, "failed to create client")
 	}
 
-	return cli, nil
+	kubeClient, err := f.KubeClient()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to create kube client")
+	}
+
+	return cli, kubeClient, nil
 }
 
-func (o *Options) runRepoPrune(f velerocli.Factory, namespace string, logger logrus.FieldLogger) error {
-	cli, err := o.initClient(f)
-	if err != nil {
-		return err
+func initRepoManager(namespace string, kubeClient kubernetes.Interface, cli client.Client, logger logrus.FieldLogger) (repomanager.Manager, error) {
+	// ensure the repo key secret is set up
+	if err := repokey.EnsureCommonRepositoryKey(kubeClient.CoreV1(), namespace); err != nil {
+		return nil, errors.Wrap(err, "failed to ensure repository key")
 	}
 
+	repoLocker := repository.NewRepoLocker()
+
 	credentialFileStore, err := credentials.NewNamespacedFileStore(
 		cli,
 		namespace,
@@ -123,23 +135,33 @@ func (o *Options) runRepoPrune(f velerocli.Factory, namespace string, logger log
 		filesystem.NewFileSystem(),
 	)
 	if err != nil {
-		return errors.Wrap(err, "failed to create namespaced file store")
+		return nil, errors.Wrap(err, "failed to create namespaced file store")
 	}
 
 	credentialSecretStore, err := credentials.NewNamespacedSecretStore(cli, namespace)
 	if err != nil {
-		return errors.Wrap(err, "failed to create namespaced secret store")
+		return nil, errors.Wrap(err, "failed to create namespaced secret store")
 	}
 
-	var repoProvider provider.Provider
-	if o.RepoType == velerov1api.BackupRepositoryTypeRestic {
-		repoProvider = provider.NewResticRepositoryProvider(credentialFileStore, filesystem.NewFileSystem(), logger)
-	} else {
-		repoProvider = provider.NewUnifiedRepoProvider(
-			credentials.CredentialGetter{
-				FromFile:   credentialFileStore,
-				FromSecret: credentialSecretStore,
-			}, o.RepoType, logger)
+	return repomanager.NewManager(
+		namespace,
+		cli,
+		repoLocker,
+		credentialFileStore,
+		credentialSecretStore,
+		logger,
+	), nil
+}
+
+func (o *Options) runRepoPrune(f velerocli.Factory, namespace string, logger logrus.FieldLogger) error {
+	cli, kubeClient, err := o.initClient(f)
+	if err != nil {
+		return err
+	}
+
+	manager, err := initRepoManager(namespace, kubeClient, cli, logger)
+	if err != nil {
+		return err
 	}
 
 	// backupRepository
@@ -149,31 +171,14 @@ func (o *Options) runRepoPrune(f velerocli.Factory, namespace string, logger log
 			BackupLocation:  o.BackupStorageLocation,
 			RepositoryType:  o.RepoType,
 		}, true)
-
 	if err != nil {
 		return errors.Wrap(err, "failed to get backup repository")
 	}
 
-	// bsl
-	bsl := &velerov1api.BackupStorageLocation{}
-	err = cli.Get(context.Background(), client.ObjectKey{Namespace: namespace, Name: repo.Spec.BackupStorageLocation}, bsl)
-	if err != nil {
-		return errors.Wrap(err, "failed to get backup storage location")
-	}
-
-	para := provider.RepoParam{
-		BackupRepo:     repo,
-		BackupLocation: bsl,
-	}
-
-	err = repoProvider.BoostRepoConnect(context.Background(), para)
-	if err != nil {
-		return errors.Wrap(err, "failed to boost repo connect")
-	}
-
-	err = repoProvider.PruneRepo(context.Background(), para)
+	err = manager.PruneRepo(repo)
 	if err != nil {
 		return errors.Wrap(err, "failed to prune repo")
 	}
+
 	return nil
 }