Merge branch 'main' of https://github.com/qiuming-best/velero into resource-policies-e2e

test/e2e/Makefile

@@ -55,7 +55,7 @@ VELERO_VERSION ?= $(VERSION)
 PLUGINS ?=
 RESTORE_HELPER_IMAGE ?=
 #Released version only
-UPGRADE_FROM_VELERO_VERSION ?= v1.8.1,v1.9.2
+UPGRADE_FROM_VELERO_VERSION ?= v1.9.6,v1.10.2
 # UPGRADE_FROM_VELERO_CLI can has the same format(a list divided by comma) with UPGRADE_FROM_VELERO_VERSION
 # Upgrade tests will be executed sequently according to the list by UPGRADE_FROM_VELERO_VERSION
 # So although length of UPGRADE_FROM_VELERO_CLI list is not equal with UPGRADE_FROM_VELERO_VERSION
@@ -63,7 +63,7 @@ UPGRADE_FROM_VELERO_VERSION ?= v1.8.1,v1.9.2
 # to the end, nil string will be set if UPGRADE_FROM_VELERO_CLI is shorter than UPGRADE_FROM_VELERO_VERSION
 UPGRADE_FROM_VELERO_CLI ?=
 
-MIGRATE_FROM_VELERO_VERSION ?= v1.8.1,self
+MIGRATE_FROM_VELERO_VERSION ?= v1.10.2,self
 MIGRATE_FROM_VELERO_CLI ?=
 
 VELERO_NAMESPACE ?= velero

test/e2e/basic/pvc-selected-node-changing.go

@@ -87,7 +87,7 @@ func (p *PVCSelectedNodeChanging) CreateResources() error {
 			p.oldNodeName = nodeName
 			fmt.Printf("Create PVC on node %s\n", p.oldNodeName)
 			pvcAnn := map[string]string{p.ann: nodeName}
-			_, err := CreatePodWithPVC(p.Client, p.namespace, p.podName, "default", p.pvcName, []string{p.volume}, pvcAnn)
+			_, err := CreatePod(p.Client, p.namespace, p.podName, "default", p.pvcName, []string{p.volume}, pvcAnn, nil)
 			Expect(err).To(Succeed())
 			err = WaitForPods(context.Background(), p.Client, p.namespace, []string{p.podName})
 			Expect(err).To(Succeed())

test/e2e/basic/storage-class-changing.go

@@ -85,7 +85,7 @@ func (s *StorageClasssChanging) CreateResources() error {
 	})
 
 	By(fmt.Sprintf("Create pod %s in namespace %s", s.podName, s.namespace), func() {
-		_, err := CreatePodWithPVC(s.Client, s.namespace, s.podName, s.srcStorageClass, "", []string{s.volume}, nil)
+		_, err := CreatePod(s.Client, s.namespace, s.podName, s.srcStorageClass, "", []string{s.volume}, nil, nil)
 		Expect(err).To(Succeed())
 	})
 	By(fmt.Sprintf("Create ConfigMap %s in namespace %s", s.configmaptName, s.VeleroCfg.VeleroNamespace), func() {

test/e2e/e2e_suite_test.go

@@ -119,6 +119,7 @@ var _ = Describe("[Backups][BackupsSync] Backups in object storage are synced to
 
 var _ = Describe("[Schedule][BR][Pause][LongTime] Backup will be created periodly by schedule defined by a Cron expression", ScheduleBackupTest)
 var _ = Describe("[Schedule][OrederedResources] Backup resources should follow the specific order in schedule", ScheduleOrderedResources)
+var _ = Describe("[Schedule][BackupCreation] Schedule controller wouldn't create a new backup when it still has pending or InProgress backup", ScheduleBackupCreationTest)
 
 var _ = Describe("[PrivilegesMgmt][SSR] Velero test on ssr object when controller namespace mix-ups", SSRTest)
 

test/e2e/migration/migration.go

@@ -100,7 +100,8 @@ func MigrationTest(useVolumeSnapshots bool, veleroCLI2Version VeleroCLI2Version)
 			flag.Parse()
 			UUIDgen, err = uuid.NewRandom()
 			Expect(err).To(Succeed())
-
+			supportUploaderType, err := IsSupportUploaderType(veleroCLI2Version.VeleroVersion)
+			Expect(err).To(Succeed())
 			oneHourTimeout, _ := context.WithTimeout(context.Background(), time.Minute*60)
 
 			if veleroCLI2Version.VeleroCLI == "" {
@@ -126,14 +127,20 @@ func MigrationTest(useVolumeSnapshots bool, veleroCLI2Version VeleroCLI2Version)
 				OriginVeleroCfg.UseNodeAgent = !useVolumeSnapshots
 				// TODO: self means 1.10 and upper version
 				if veleroCLI2Version.VeleroVersion != "self" {
+					Expect(err).To(Succeed())
 					fmt.Printf("Using default images address of Velero CLI %s\n", veleroCLI2Version.VeleroVersion)
 					OriginVeleroCfg.VeleroImage = ""
 					OriginVeleroCfg.RestoreHelperImage = ""
 					OriginVeleroCfg.Plugins = ""
 					//TODO: Remove this once origin Velero version is 1.10 and upper
 					OriginVeleroCfg.UploaderType = ""
-					OriginVeleroCfg.UseNodeAgent = false
-					OriginVeleroCfg.UseRestic = !useVolumeSnapshots
+					if supportUploaderType {
+						OriginVeleroCfg.UseRestic = false
+						OriginVeleroCfg.UseNodeAgent = !useVolumeSnapshots
+					} else {
+						OriginVeleroCfg.UseRestic = !useVolumeSnapshots
+						OriginVeleroCfg.UseNodeAgent = false
+					}
 				}
 
 				Expect(VeleroInstall(context.Background(), &OriginVeleroCfg)).To(Succeed())
@@ -165,11 +172,7 @@ func MigrationTest(useVolumeSnapshots bool, veleroCLI2Version VeleroCLI2Version)
 				BackupStorageClassCfg.IncludeResources = "StorageClass"
 				BackupStorageClassCfg.IncludeClusterResources = true
 				//TODO Remove UseRestic parameter once minor version is 1.10 or upper
-				BackupStorageClassCfg.UseResticIfFSBackup = true
-				if veleroCLI2Version.VeleroVersion == "self" {
-					BackupStorageClassCfg.UseResticIfFSBackup = false
-				}
-
+				BackupStorageClassCfg.UseResticIfFSBackup = !supportUploaderType
 				Expect(VeleroBackupNamespace(context.Background(), OriginVeleroCfg.VeleroCLI,
 					OriginVeleroCfg.VeleroNamespace, BackupStorageClassCfg)).To(Succeed(), func() string {
 					RunDebug(context.Background(), veleroCfg.VeleroCLI, veleroCfg.VeleroNamespace, BackupStorageClassCfg.BackupName, "")
@@ -184,10 +187,8 @@ func MigrationTest(useVolumeSnapshots bool, veleroCLI2Version VeleroCLI2Version)
 				BackupCfg.Selector = ""
 				BackupCfg.DefaultVolumesToFsBackup = !useVolumeSnapshots
 				//TODO Remove UseRestic parameter once minor version is 1.10 or upper
-				BackupCfg.UseResticIfFSBackup = true
-				if veleroCLI2Version.VeleroVersion == "self" {
-					BackupCfg.UseResticIfFSBackup = false
-				}
+				BackupCfg.UseResticIfFSBackup = !supportUploaderType
+
 				Expect(VeleroBackupNamespace(context.Background(), OriginVeleroCfg.VeleroCLI,
 					OriginVeleroCfg.VeleroNamespace, BackupCfg)).To(Succeed(), func() string {
 					RunDebug(context.Background(), OriginVeleroCfg.VeleroCLI, OriginVeleroCfg.VeleroNamespace, BackupCfg.BackupName, "")

test/e2e/pv-backup/pv-backup-filter.go

@@ -96,7 +96,7 @@ func (p *PVBackupFiltering) CreateResources() error {
 				podName := fmt.Sprintf("pod-%d", i)
 				pods = append(pods, podName)
 				By(fmt.Sprintf("Create pod %s in namespace %s", podName, ns), func() {
-					pod, err := CreatePodWithPVC(p.Client, ns, podName, "e2e-storage-class", "", volumes, nil)
+					pod, err := CreatePod(p.Client, ns, podName, "e2e-storage-class", "", volumes, nil, nil)
 					Expect(err).To(Succeed())
 					ann := map[string]string{
 						p.annotation: volumesToAnnotation,

test/e2e/resourcepolicies/resource_policies.go

@@ -84,7 +84,8 @@ func (r *ResourcePoliciesCase) Init() error {
 		"create", "--namespace", VeleroCfg.VeleroNamespace, "backup", r.BackupName,
 		"--resource-policies-configmap", r.cmName,
 		"--include-namespaces", strings.Join(*r.NSIncluded, ","),
-		"--default-volumes-to-fs-backup", "--wait",
+		"--default-volumes-to-fs-backup",
+		"--snapshot-volumes=false", "--wait",
 	}
 
 	r.RestoreArgs = []string{
@@ -104,7 +105,7 @@ func (r *ResourcePoliciesCase) CreateResources() error {
 	r.Ctx, _ = context.WithTimeout(context.Background(), 60*time.Minute)
 
 	By(("Installing storage class..."), func() {
-		Expect(r.installTestStorageClass(fmt.Sprintf("testdata/storage-class/%s.yaml", VeleroCfg.CloudProvider))).To(Succeed(), "Failed to install storage class")
+		Expect(r.installTestStorageClasses(fmt.Sprintf("testdata/storage-class/%s.yaml", VeleroCfg.CloudProvider))).To(Succeed(), "Failed to install storage class")
 	})
 
 	By(fmt.Sprintf("Create configmap %s in namespaces %s for workload\n", r.cmName, r.VeleroCfg.VeleroNamespace), func() {
@@ -130,7 +131,6 @@ func (r *ResourcePoliciesCase) CreateResources() error {
 		})
 
 		// Create deployment
-		fmt.Printf("Creating deployment in namespaces ...%s\n", namespace)
 		By(fmt.Sprintf("Creating deployment in namespaces ...%s\n", namespace), func() {
 			Expect(r.createDeploymentWithVolume(namespace, volList)).To(Succeed(), fmt.Sprintf("Failed to create deployment namespace %s", namespace))
 		})
@@ -196,7 +196,7 @@ func (r *ResourcePoliciesCase) createPVC(index int, namespace string, volList []
 	var err error
 	for i := range volList {
 		pvcName := fmt.Sprintf("pvc-%d", i)
-		fmt.Printf("Creating PVC %s in namespaces ...%s\n", pvcName, namespace)
+		By(fmt.Sprintf("Creating PVC %s in namespaces ...%s\n", pvcName, namespace))
 		if index%3 == 0 {
 			pvcBuilder := NewPVC(namespace, pvcName).WithStorageClass("e2e-storage-class") // Testing sc should not backup
 			err = CreatePvc(r.Client, pvcBuilder)
@@ -255,7 +255,7 @@ func (r *ResourcePoliciesCase) deleteTestStorageClassList(scList []string) error
 	return nil
 }
 
-func (r *ResourcePoliciesCase) installTestStorageClass(path string) error {
+func (r *ResourcePoliciesCase) installTestStorageClasses(path string) error {
 	err := InstallStorageClass(r.Ctx, path)
 	if err != nil {
 		return err

test/e2e/schedule/schedule-backup-creation.go

@@ -0,0 +1,137 @@
+package schedule
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "github.com/vmware-tanzu/velero/test/e2e"
+	. "github.com/vmware-tanzu/velero/test/e2e/test"
+	. "github.com/vmware-tanzu/velero/test/e2e/util/k8s"
+	. "github.com/vmware-tanzu/velero/test/e2e/util/velero"
+)
+
+type ScheduleBackupCreation struct {
+	TestCase
+	namespace        string
+	ScheduleName     string
+	ScheduleArgs     []string
+	Period           int //Limitation: The unit is minitue only and 60 is divisible by it
+	randBackupName   string
+	verifyTimes      int
+	volume           string
+	podName          string
+	pvcName          string
+	podAnn           map[string]string
+	podSleepDuration time.Duration
+}
+
+var ScheduleBackupCreationTest func() = TestFunc(&ScheduleBackupCreation{namespace: "sch1", TestCase: TestCase{NSBaseName: "schedule-backup-creation-test"}})
+
+func (n *ScheduleBackupCreation) Init() error {
+	n.VeleroCfg = VeleroCfg
+	n.Client = *n.VeleroCfg.ClientToInstallVelero
+	n.Period = 3      // Unit is minute
+	n.verifyTimes = 5 // More larger verify times more confidence we have
+	podSleepDurationStr := "300s"
+	n.podSleepDuration, _ = time.ParseDuration(podSleepDurationStr)
+	n.TestMsg = &TestMSG{
+		Desc:      "Schedule controller wouldn't create a new backup when it still has pending or InProgress backup",
+		FailedMSG: "Failed to verify schedule back creation behavior",
+		Text:      "Schedule controller wouldn't create a new backup when it still has pending or InProgress backup",
+	}
+	n.podAnn = map[string]string{
+		"pre.hook.backup.velero.io/container": n.podName,
+		"pre.hook.backup.velero.io/command":   "[\"sleep\", \"" + podSleepDurationStr + "\"]",
+		"pre.hook.backup.velero.io/timeout":   "600s",
+	}
+	n.volume = "volume-1"
+	n.podName = "pod-1"
+	n.pvcName = "pvc-1"
+	return nil
+}
+
+func (n *ScheduleBackupCreation) StartRun() error {
+	n.namespace = fmt.Sprintf("%s-%s", n.NSBaseName, "ns")
+	n.ScheduleName = n.ScheduleName + "schedule-" + UUIDgen.String()
+	n.RestoreName = n.RestoreName + "restore-ns-mapping-" + UUIDgen.String()
+
+	n.ScheduleArgs = []string{
+		"--include-namespaces", n.namespace,
+		"--schedule=*/" + fmt.Sprintf("%v", n.Period) + " * * * *",
+	}
+	Expect(n.Period < 30).To(Equal(true))
+	return nil
+}
+func (p *ScheduleBackupCreation) CreateResources() error {
+	p.Ctx, _ = context.WithTimeout(context.Background(), 60*time.Minute)
+	By(fmt.Sprintf("Create namespace %s", p.namespace), func() {
+		Expect(CreateNamespace(context.Background(), p.Client, p.namespace)).To(Succeed(),
+			fmt.Sprintf("Failed to create namespace %s", p.namespace))
+	})
+
+	By(fmt.Sprintf("Create pod %s in namespace %s", p.podName, p.namespace), func() {
+		_, err := CreatePod(p.Client, p.namespace, p.podName, "default", p.pvcName, []string{p.volume}, nil, p.podAnn)
+		Expect(err).To(Succeed())
+		err = WaitForPods(context.Background(), p.Client, p.namespace, []string{p.podName})
+		Expect(err).To(Succeed())
+	})
+	return nil
+}
+
+func (n *ScheduleBackupCreation) Backup() error {
+	// Wait until the beginning of the given period to create schedule, it will give us
+	//   a predictable period to wait for the first scheduled backup, and verify no immediate
+	//   scheduled backup was created between schedule creation and first scheduled backup.
+	By(fmt.Sprintf("Creating schedule %s ......\n", n.ScheduleName), func() {
+		for i := 0; i < n.Period*60/30; i++ {
+			time.Sleep(30 * time.Second)
+			now := time.Now().Minute()
+			triggerNow := now % n.Period
+			if triggerNow == 0 {
+				Expect(VeleroScheduleCreate(n.Ctx, VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, n.ScheduleName, n.ScheduleArgs)).To(Succeed(), func() string {
+					RunDebug(context.Background(), VeleroCfg.VeleroCLI, VeleroCfg.VeleroNamespace, "", "")
+					return "Fail to restore workload"
+				})
+				break
+			}
+		}
+	})
+
+	By("Delay one more minute to make sure the new backup was created in the given period", func() {
+		time.Sleep(1 * time.Minute)
+	})
+
+	By(fmt.Sprintf("Get backups every %d minute, and backups count should increase 1 more step in the same pace\n", n.Period), func() {
+		for i := 1; i <= n.verifyTimes; i++ {
+			fmt.Printf("Start to sleep %d minute #%d time...\n", n.podSleepDuration, i)
+			mi, _ := time.ParseDuration("60s")
+			time.Sleep(n.podSleepDuration + mi)
+			bMap := make(map[string]string)
+			backupsInfo, err := GetScheduledBackupsCreationTime(context.Background(), VeleroCfg.VeleroCLI, "default", n.ScheduleName)
+			Expect(err).To(Succeed())
+			Expect(len(backupsInfo) == i).To(Equal(true))
+			for index, bi := range backupsInfo {
+				bList := strings.Split(bi, ",")
+				fmt.Printf("Backup %d: %v\n", index, bList)
+				bMap[bList[0]] = bList[1]
+				_, err := time.Parse("2006-01-02 15:04:05 -0700 MST", bList[1])
+				Expect(err).To(Succeed())
+			}
+			if i == n.verifyTimes-1 {
+				backupInfo := backupsInfo[rand.Intn(len(backupsInfo))]
+				n.randBackupName = strings.Split(backupInfo, ",")[0]
+			}
+		}
+	})
+	return nil
+}
+
+func (n *ScheduleBackupCreation) Restore() error {
+	return nil
+}

test/e2e/schedule/schedule.go

@@ -31,7 +31,7 @@ func (n *ScheduleBackup) Init() error {
 	n.VeleroCfg = VeleroCfg
 	n.Client = *n.VeleroCfg.ClientToInstallVelero
 	n.Period = 3      // Unit is minute
-	n.verifyTimes = 5 // More verify times more confidence
+	n.verifyTimes = 5 // More larger verify times more confidence we have
 	n.TestMsg = &TestMSG{
 		Desc:      "Set up a scheduled backup defined by a Cron expression",
 		FailedMSG: "Failed to schedule a backup",

test/e2e/upgrade/upgrade.go

@@ -97,6 +97,8 @@ func BackupUpgradeRestoreTest(useVolumeSnapshots bool, veleroCLI2Version VeleroC
 			UUIDgen, err = uuid.NewRandom()
 			Expect(err).To(Succeed())
 			oneHourTimeout, _ := context.WithTimeout(context.Background(), time.Minute*60)
+			supportUploaderType, err := IsSupportUploaderType(veleroCLI2Version.VeleroVersion)
+			Expect(err).To(Succeed())
 			if veleroCLI2Version.VeleroCLI == "" {
 				//Assume tag of velero server image is identical to velero CLI version
 				//Download velero CLI if it's empty according to velero CLI version
@@ -118,8 +120,13 @@ func BackupUpgradeRestoreTest(useVolumeSnapshots bool, veleroCLI2Version VeleroC
 				tmpCfgForOldVeleroInstall.RestoreHelperImage = ""
 				tmpCfgForOldVeleroInstall.Plugins = ""
 				tmpCfgForOldVeleroInstall.UploaderType = ""
-				tmpCfgForOldVeleroInstall.UseNodeAgent = false
-				tmpCfgForOldVeleroInstall.UseRestic = !useVolumeSnapshots
+				if supportUploaderType {
+					tmpCfgForOldVeleroInstall.UseRestic = false
+					tmpCfgForOldVeleroInstall.UseNodeAgent = !useVolumeSnapshots
+				} else {
+					tmpCfgForOldVeleroInstall.UseRestic = !useVolumeSnapshots
+					tmpCfgForOldVeleroInstall.UseNodeAgent = false
+				}
 
 				Expect(VeleroInstall(context.Background(), &tmpCfgForOldVeleroInstall)).To(Succeed())
 				Expect(CheckVeleroVersion(context.Background(), tmpCfgForOldVeleroInstall.VeleroCLI,
@@ -152,7 +159,7 @@ func BackupUpgradeRestoreTest(useVolumeSnapshots bool, veleroCLI2Version VeleroC
 				BackupCfg.DefaultVolumesToFsBackup = !useVolumeSnapshots
 				BackupCfg.Selector = ""
 				//TODO: pay attention to this param, remove it when restic is not the default backup tool any more.
-				BackupCfg.UseResticIfFSBackup = true
+				BackupCfg.UseResticIfFSBackup = !supportUploaderType
 				Expect(VeleroBackupNamespace(oneHourTimeout, tmpCfg.UpgradeFromVeleroCLI,
 					tmpCfg.VeleroNamespace, BackupCfg)).To(Succeed(), func() string {
 					RunDebug(context.Background(), tmpCfg.UpgradeFromVeleroCLI, tmpCfg.VeleroNamespace,
@@ -202,13 +209,22 @@ func BackupUpgradeRestoreTest(useVolumeSnapshots bool, veleroCLI2Version VeleroC
 			}
 
 			By(fmt.Sprintf("Upgrade Velero by CLI %s", tmpCfg.VeleroCLI), func() {
+
 				tmpCfg.GCFrequency = ""
-				tmpCfg.UseNodeAgent = !useVolumeSnapshots
 				tmpCfg.UseRestic = false
-				tmpCfg.UploaderType = "restic"
-				Expect(VeleroUpgrade(context.Background(), tmpCfg)).To(Succeed())
-				Expect(CheckVeleroVersion(context.Background(), tmpCfg.VeleroCLI,
-					tmpCfg.VeleroVersion)).To(Succeed())
+				tmpCfg.UseNodeAgent = !useVolumeSnapshots
+				Expect(err).To(Succeed())
+				if supportUploaderType {
+					Expect(VeleroInstall(context.Background(), &tmpCfg)).To(Succeed())
+					Expect(CheckVeleroVersion(context.Background(), tmpCfg.VeleroCLI,
+						tmpCfg.VeleroVersion)).To(Succeed())
+				} else {
+					// For upgrade from v1.9 or other version below v1.9
+					tmpCfg.UploaderType = "restic"
+					Expect(VeleroUpgrade(context.Background(), tmpCfg)).To(Succeed())
+					Expect(CheckVeleroVersion(context.Background(), tmpCfg.VeleroCLI,
+						tmpCfg.VeleroVersion)).To(Succeed())
+				}
 			})
 
 			By(fmt.Sprintf("Restore %s", upgradeNamespace), func() {

test/e2e/util/k8s/common.go

@@ -25,7 +25,6 @@ import (
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
 	corev1 "k8s.io/api/core/v1"
-	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/wait"
 
@@ -64,12 +63,12 @@ func WaitForPods(ctx context.Context, client TestClient, namespace string, pods
 			checkPod, err := client.ClientGo.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
 			if err != nil {
 				//Should ignore "etcdserver: request timed out" kind of errors, try to get pod status again before timeout.
-				fmt.Println(errors.Wrap(err, fmt.Sprintf("Failed to verify pod %s/%s is %s, try again...\n", namespace, podName, corev1api.PodRunning)))
+				fmt.Println(errors.Wrap(err, fmt.Sprintf("Failed to verify pod %s/%s is %s, try again...\n", namespace, podName, corev1.PodRunning)))
 				return false, nil
 			}
 			// If any pod is still waiting we don't need to check any more so return and wait for next poll interval
-			if checkPod.Status.Phase != corev1api.PodRunning {
-				fmt.Printf("Pod %s is in state %s waiting for it to be %s\n", podName, checkPod.Status.Phase, corev1api.PodRunning)
+			if checkPod.Status.Phase != corev1.PodRunning {
+				fmt.Printf("Pod %s is in state %s waiting for it to be %s\n", podName, checkPod.Status.Phase, corev1.PodRunning)
 				return false, nil
 			}
 		}
@@ -271,36 +270,6 @@ func PrepareVolumeList(volumeNameList []string) (vols []*corev1.Volume) {
 	return
 }
 
-func CreatePodWithPVC(client TestClient, ns, podName, sc, pvcName string, volumeNameList []string, pvcAnn map[string]string) (*corev1.Pod, error) {
-	volumes := []corev1.Volume{}
-	for _, volume := range volumeNameList {
-		var _pvcName string
-		if pvcName == "" {
-			_pvcName = fmt.Sprintf("pvc-%s", volume)
-		} else {
-			_pvcName = pvcName
-		}
-		pvc, err := CreatePVC(client, ns, _pvcName, sc, pvcAnn)
-		if err != nil {
-			return nil, err
-		}
-		volumes = append(volumes, corev1.Volume{
-			Name: volume,
-			VolumeSource: corev1.VolumeSource{
-				PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
-					ClaimName: pvc.Name,
-					ReadOnly:  false,
-				},
-			},
-		})
-	}
-	pod, err := CreatePod(client, ns, podName, volumes)
-	if err != nil {
-		return nil, err
-	}
-	return pod, nil
-}
-
 func CreateFileToPod(ctx context.Context, namespace, podName, containerName, volume, filename, content string) error {
 	arg := []string{"exec", "-n", namespace, "-c", containerName, podName,
 		"--", "/bin/sh", "-c", fmt.Sprintf("echo ns-%s pod-%s volume-%s  > /%s/%s", namespace, podName, volume, volume, filename)}

test/e2e/util/k8s/pod.go

@@ -26,7 +26,34 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func CreatePod(client TestClient, ns, name string, volumes []corev1.Volume) (*corev1.Pod, error) {
+func CreatePod(client TestClient, ns, name, sc, pvcName string, volumeNameList []string, pvcAnn, ann map[string]string) (*corev1.Pod, error) {
+	if pvcName != "" && len(volumeNameList) != 1 {
+		return nil, errors.New("Volume name list should contain only 1 since PVC name is not empty")
+	}
+	volumes := []corev1.Volume{}
+	for _, volume := range volumeNameList {
+		var _pvcName string
+		if pvcName == "" {
+			_pvcName = fmt.Sprintf("pvc-%s", volume)
+		} else {
+			_pvcName = pvcName
+		}
+		pvc, err := CreatePVC(client, ns, _pvcName, sc, pvcAnn)
+		if err != nil {
+			return nil, err
+		}
+
+		volumes = append(volumes, corev1.Volume{
+			Name: volume,
+			VolumeSource: corev1.VolumeSource{
+				PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+					ClaimName: pvc.Name,
+					ReadOnly:  false,
+				},
+			},
+		})
+	}
+
 	vmList := []corev1.VolumeMount{}
 	for _, v := range volumes {
 		vmList = append(vmList, corev1.VolumeMount{
@@ -34,9 +61,11 @@ func CreatePod(client TestClient, ns, name string, volumes []corev1.Volume) (*co
 			MountPath: "/" + v.Name,
 		})
 	}
+
 	p := &corev1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
-			Name: name,
+			Name:        name,
+			Annotations: ann,
 		},
 		Spec: corev1.PodSpec{
 			Containers: []corev1.Container{

test/e2e/util/velero/velero_utils.go

@@ -38,6 +38,8 @@ import (
 
 	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	ver "k8s.io/apimachinery/pkg/util/version"
+
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	cliinstall "github.com/vmware-tanzu/velero/pkg/cmd/cli/install"
 	"github.com/vmware-tanzu/velero/pkg/cmd/util/flag"
@@ -102,6 +104,13 @@ var pluginsMatrix = map[string]map[string][]string{
 		"gcp":       {"velero/velero-plugin-for-gcp:v1.6.0"},
 		"azure-csi": {"velero/velero-plugin-for-microsoft-azure:v1.6.0", "velero/velero-plugin-for-csi:v0.4.0"},
 	},
+	"v1.11": {
+		"aws":       {"velero/velero-plugin-for-aws:v1.7.0"},
+		"azure":     {"velero/velero-plugin-for-microsoft-azure:v1.7.0"},
+		"vsphere":   {"velero/velero-plugin-for-aws:v1.7.0", "vsphereveleroplugin/velero-plugin-for-vsphere:v1.4.2"},
+		"gcp":       {"velero/velero-plugin-for-gcp:v1.7.0"},
+		"azure-csi": {"velero/velero-plugin-for-microsoft-azure:v1.7.0", "velero/velero-plugin-for-csi:v0.5.0"},
+	},
 	"main": {
 		"aws":       {"velero/velero-plugin-for-aws:main"},
 		"azure":     {"velero/velero-plugin-for-microsoft-azure:main"},
@@ -1290,3 +1299,22 @@ func GetPVB(ctx context.Context, veleroNamespace, namespace string) ([]string, e
 func GetPVR(ctx context.Context, veleroNamespace, namespace string) ([]string, error) {
 	return GetVeleroResource(ctx, veleroNamespace, namespace, "podvolumerestore")
 }
+
+func IsSupportUploaderType(version string) (bool, error) {
+	if strings.Contains(version, "self") {
+		return true, nil
+	}
+	verSupportUploaderType, err := ver.ParseSemantic("v1.10.0")
+	if err != nil {
+		return false, err
+	}
+	v, err := ver.ParseSemantic(version)
+	if err != nil {
+		return false, err
+	}
+	if v.AtLeast(verSupportUploaderType) {
+		return true, nil
+	} else {
+		return false, nil
+	}
+}