Support using image registry proxy in more cases.

Signed-off-by: Xun Jiang <xun.jiang@broadcom.com>

test/util/k8s/deployment.go

@@ -18,11 +18,12 @@ package k8s
 
 import (
 	"fmt"
+	"path"
 	"time"
 
 	"golang.org/x/net/context"
 	apps "k8s.io/api/apps/v1"
-	v1 "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"
 	clientset "k8s.io/client-go/kubernetes"
@@ -36,6 +37,7 @@ const (
 	PollInterval         = 2 * time.Second
 	PollTimeout          = 15 * time.Minute
 	DefaultContainerName = "container-busybox"
+	TestImage            = "busybox:1.37.0"
 )
 
 // DeploymentBuilder builds Deployment objects.
@@ -48,29 +50,33 @@ func (d *DeploymentBuilder) Result() *apps.Deployment {
 }
 
 // newDeployment returns a RollingUpdate Deployment with a fake container image
-func NewDeployment(name, ns string, replicas int32, labels map[string]string, containers []v1.Container) *DeploymentBuilder {
-	if containers == nil {
-		containers = []v1.Container{
-			{
-				Name:    DefaultContainerName,
-				Image:   "busybox:1.37.0",
-				Command: []string{"sleep", "1000000"},
-				// Make pod obeys the restricted pod security standards.
-				SecurityContext: &v1.SecurityContext{
-					AllowPrivilegeEscalation: boolptr.False(),
-					Capabilities: &v1.Capabilities{
-						Drop: []v1.Capability{"ALL"},
-					},
-					RunAsNonRoot: boolptr.True(),
-					RunAsUser:    func(i int64) *int64 { return &i }(65534),
-					RunAsGroup:   func(i int64) *int64 { return &i }(65534),
-					SeccompProfile: &v1.SeccompProfile{
-						Type: v1.SeccompProfileTypeRuntimeDefault,
-					},
+func NewDeployment(name, ns string, replicas int32, labels map[string]string, imageRegistryProxy string) *DeploymentBuilder {
+	imageAddress := TestImage
+	if imageRegistryProxy != "" {
+		imageAddress = path.Join(imageRegistryProxy, TestImage)
+	}
+
+	containers := []corev1api.Container{
+		{
+			Name:    DefaultContainerName,
+			Image:   imageAddress,
+			Command: []string{"sleep", "1000000"},
+			// Make pod obeys the restricted pod security standards.
+			SecurityContext: &corev1api.SecurityContext{
+				AllowPrivilegeEscalation: boolptr.False(),
+				Capabilities: &corev1api.Capabilities{
+					Drop: []corev1api.Capability{"ALL"},
+				},
+				RunAsNonRoot: boolptr.True(),
+				RunAsUser:    func(i int64) *int64 { return &i }(65534),
+				RunAsGroup:   func(i int64) *int64 { return &i }(65534),
+				SeccompProfile: &corev1api.SeccompProfile{
+					Type: corev1api.SeccompProfileTypeRuntimeDefault,
 				},
 			},
-		}
+		},
 	}
+
 	return &DeploymentBuilder{
 		&apps.Deployment{
 			TypeMeta: metav1.TypeMeta{
@@ -89,14 +95,14 @@ func NewDeployment(name, ns string, replicas int32, labels map[string]string, co
 					Type:          apps.RollingUpdateDeploymentStrategyType,
 					RollingUpdate: new(apps.RollingUpdateDeployment),
 				},
-				Template: v1.PodTemplateSpec{
+				Template: corev1api.PodTemplateSpec{
 					ObjectMeta: metav1.ObjectMeta{
 						Labels: labels,
 					},
-					Spec: v1.PodSpec{
-						SecurityContext: &v1.PodSecurityContext{
+					Spec: corev1api.PodSpec{
+						SecurityContext: &corev1api.PodSecurityContext{
 							FSGroup:             func(i int64) *int64 { return &i }(65534),
-							FSGroupChangePolicy: func(policy v1.PodFSGroupChangePolicy) *v1.PodFSGroupChangePolicy { return &policy }(v1.FSGroupChangeAlways),
+							FSGroupChangePolicy: func(policy corev1api.PodFSGroupChangePolicy) *corev1api.PodFSGroupChangePolicy { return &policy }(corev1api.FSGroupChangeAlways),
 						},
 						Containers: containers,
 					},
@@ -106,10 +112,10 @@ func NewDeployment(name, ns string, replicas int32, labels map[string]string, co
 	}
 }
 
-func (d *DeploymentBuilder) WithVolume(volumes []*v1.Volume) *DeploymentBuilder {
-	vmList := []v1.VolumeMount{}
+func (d *DeploymentBuilder) WithVolume(volumes []*corev1api.Volume) *DeploymentBuilder {
+	vmList := []corev1api.VolumeMount{}
 	for _, v := range volumes {
-		vmList = append(vmList, v1.VolumeMount{
+		vmList = append(vmList, corev1api.VolumeMount{
 			Name:      v.Name,
 			MountPath: "/" + v.Name,
 		})

test/util/k8s/pod.go

@@ -19,20 +19,32 @@ package k8s
 import (
 	"context"
 	"fmt"
+	"path"
 
 	"github.com/pkg/errors"
-	corev1 "k8s.io/api/core/v1"
-	v1 "k8s.io/api/core/v1"
+	corev1api "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/vmware-tanzu/velero/pkg/util/boolptr"
 )
 
-func CreatePod(client TestClient, ns, name, sc, pvcName string, volumeNameList []string, pvcAnn, ann map[string]string) (*corev1.Pod, error) {
+func CreatePod(
+	client TestClient,
+	ns, name, sc, pvcName string,
+	volumeNameList []string,
+	pvcAnn, ann map[string]string,
+	imageRegistryProxy string,
+) (*corev1api.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{}
+
+	imageAddress := TestImage
+	if imageRegistryProxy != "" {
+		imageAddress = path.Join(imageRegistryProxy, TestImage)
+	}
+
+	volumes := []corev1api.Volume{}
 	for _, volume := range volumeNameList {
 		var _pvcName string
 		if pvcName == "" {
@@ -45,10 +57,10 @@ func CreatePod(client TestClient, ns, name, sc, pvcName string, volumeNameList [
 			return nil, err
 		}
 
-		volumes = append(volumes, corev1.Volume{
+		volumes = append(volumes, corev1api.Volume{
 			Name: volume,
-			VolumeSource: corev1.VolumeSource{
-				PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+			VolumeSource: corev1api.VolumeSource{
+				PersistentVolumeClaim: &corev1api.PersistentVolumeClaimVolumeSource{
 					ClaimName: pvc.Name,
 					ReadOnly:  false,
 				},
@@ -56,41 +68,41 @@ func CreatePod(client TestClient, ns, name, sc, pvcName string, volumeNameList [
 		})
 	}
 
-	vmList := []corev1.VolumeMount{}
+	vmList := []corev1api.VolumeMount{}
 	for _, v := range volumes {
-		vmList = append(vmList, corev1.VolumeMount{
+		vmList = append(vmList, corev1api.VolumeMount{
 			Name:      v.Name,
 			MountPath: "/" + v.Name,
 		})
 	}
 
-	p := &corev1.Pod{
+	p := &corev1api.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        name,
 			Annotations: ann,
 		},
-		Spec: corev1.PodSpec{
-			SecurityContext: &v1.PodSecurityContext{
+		Spec: corev1api.PodSpec{
+			SecurityContext: &corev1api.PodSecurityContext{
 				FSGroup:             func(i int64) *int64 { return &i }(65534),
-				FSGroupChangePolicy: func(policy v1.PodFSGroupChangePolicy) *v1.PodFSGroupChangePolicy { return &policy }(v1.FSGroupChangeAlways),
+				FSGroupChangePolicy: func(policy corev1api.PodFSGroupChangePolicy) *corev1api.PodFSGroupChangePolicy { return &policy }(corev1api.FSGroupChangeAlways),
 			},
-			Containers: []corev1.Container{
+			Containers: []corev1api.Container{
 				{
 					Name:         name,
-					Image:        "busybox:1.37.0",
+					Image:        imageAddress,
 					Command:      []string{"sleep", "3600"},
 					VolumeMounts: vmList,
 					// Make pod obeys the restricted pod security standards.
-					SecurityContext: &v1.SecurityContext{
+					SecurityContext: &corev1api.SecurityContext{
 						AllowPrivilegeEscalation: boolptr.False(),
-						Capabilities: &v1.Capabilities{
-							Drop: []v1.Capability{"ALL"},
+						Capabilities: &corev1api.Capabilities{
+							Drop: []corev1api.Capability{"ALL"},
 						},
 						RunAsNonRoot: boolptr.True(),
 						RunAsUser:    func(i int64) *int64 { return &i }(65534),
 						RunAsGroup:   func(i int64) *int64 { return &i }(65534),
-						SeccompProfile: &v1.SeccompProfile{
-							Type: v1.SeccompProfileTypeRuntimeDefault,
+						SeccompProfile: &corev1api.SeccompProfile{
+							Type: corev1api.SeccompProfileTypeRuntimeDefault,
 						},
 					},
 				},
@@ -102,11 +114,11 @@ func CreatePod(client TestClient, ns, name, sc, pvcName string, volumeNameList [
 	return client.ClientGo.CoreV1().Pods(ns).Create(context.TODO(), p, metav1.CreateOptions{})
 }
 
-func GetPod(ctx context.Context, client TestClient, namespace string, pod string) (*corev1.Pod, error) {
+func GetPod(ctx context.Context, client TestClient, namespace string, pod string) (*corev1api.Pod, error) {
 	return client.ClientGo.CoreV1().Pods(namespace).Get(ctx, pod, metav1.GetOptions{})
 }
 
-func AddAnnotationToPod(ctx context.Context, client TestClient, namespace, podName string, ann map[string]string) (*corev1.Pod, error) {
+func AddAnnotationToPod(ctx context.Context, client TestClient, namespace, podName string, ann map[string]string) (*corev1api.Pod, error) {
 	newPod, err := GetPod(ctx, client, namespace, podName)
 	if err != nil {
 		return nil, errors.Wrap(err, fmt.Sprintf("Fail to ge pod %s in namespace %s", podName, namespace))
@@ -125,6 +137,6 @@ func AddAnnotationToPod(ctx context.Context, client TestClient, namespace, podNa
 	return client.ClientGo.CoreV1().Pods(namespace).Update(ctx, newPod, metav1.UpdateOptions{})
 }
 
-func ListPods(ctx context.Context, client TestClient, namespace string) (*corev1.PodList, error) {
+func ListPods(ctx context.Context, client TestClient, namespace string) (*corev1api.PodList, error) {
 	return client.ClientGo.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{})
 }

test/util/kibishii/kibishii_utils.go

@@ -18,6 +18,8 @@ package kibishii
 
 import (
 	"fmt"
+	"html/template"
+	"os"
 	"os/exec"
 	"path"
 	"strconv"
@@ -27,7 +29,10 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
+	appsv1api "k8s.io/api/apps/v1"
+	corev1api "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"sigs.k8s.io/yaml"
 
 	veleroexec "github.com/vmware-tanzu/velero/pkg/util/exec"
 	. "github.com/vmware-tanzu/velero/test"
@@ -102,9 +107,17 @@ func RunKibishiiTests(
 		}
 	}()
 	fmt.Printf("KibishiiPrepareBeforeBackup %s\n", time.Now().Format("2006-01-02 15:04:05"))
-	if err := KibishiiPrepareBeforeBackup(oneHourTimeout, client, providerName,
-		kibishiiNamespace, registryCredentialFile, veleroFeatures,
-		kibishiiDirectory, useVolumeSnapshots, DefaultKibishiiData); err != nil {
+	if err := KibishiiPrepareBeforeBackup(
+		oneHourTimeout,
+		client,
+		providerName,
+		kibishiiNamespace,
+		registryCredentialFile,
+		veleroFeatures,
+		kibishiiDirectory,
+		DefaultKibishiiData,
+		veleroCfg.ImageRegistryProxy,
+	); err != nil {
 		return errors.Wrapf(err, "Failed to install and prepare data for kibishii %s", kibishiiNamespace)
 	}
 	fmt.Printf("KibishiiPrepareBeforeBackup done %s\n", time.Now().Format("2006-01-02 15:04:05"))
@@ -264,8 +277,15 @@ func RunKibishiiTests(
 	return nil
 }
 
-func installKibishii(ctx context.Context, namespace string, cloudPlatform, veleroFeatures,
-	kibishiiDirectory string, useVolumeSnapshots bool, workerReplicas int) error {
+func installKibishii(
+	ctx context.Context,
+	namespace string,
+	cloudPlatform,
+	veleroFeatures,
+	kibishiiDirectory string,
+	workerReplicas int,
+	imageRegistryProxy string,
+) error {
 	if strings.EqualFold(cloudPlatform, Azure) &&
 		strings.EqualFold(veleroFeatures, FeatureCSI) {
 		cloudPlatform = AzureCSI
@@ -274,6 +294,29 @@ func installKibishii(ctx context.Context, namespace string, cloudPlatform, veler
 		strings.EqualFold(veleroFeatures, FeatureCSI) {
 		cloudPlatform = AwsCSI
 	}
+
+	if strings.EqualFold(cloudPlatform, Vsphere) {
+		if strings.HasPrefix(kibishiiDirectory, "https://") {
+			return errors.New("vSphere needs to download the Kibishii repository first because it needs to inject some image patch file to work.")
+		}
+
+		kibishiiImage := readBaseKibishiiImage(path.Join(kibishiiDirectory, "base", "kibishii.yaml"))
+		if err := generateKibishiiImagePatch(
+			path.Join(imageRegistryProxy, kibishiiImage),
+			path.Join(kibishiiDirectory, cloudPlatform, "worker-image-patch.yaml"),
+		); err != nil {
+			return nil
+		}
+
+		jumpPadImage := readBaseJumpPadImage(path.Join(kibishiiDirectory, "base", "jump-pad.yaml"))
+		if err := generateJumpPadPatch(
+			path.Join(imageRegistryProxy, jumpPadImage),
+			path.Join(kibishiiDirectory, cloudPlatform, "jump-pad-image-patch.yaml"),
+		); err != nil {
+			return nil
+		}
+	}
+
 	// We use kustomize to generate YAML for Kibishii from the checked-in yaml directories
 	kibishiiInstallCmd := exec.CommandContext(ctx, "kubectl", "apply", "-n", namespace, "-k",
 		path.Join(kibishiiDirectory, cloudPlatform), "--timeout=90s")
@@ -313,16 +356,134 @@ func installKibishii(ctx context.Context, namespace string, cloudPlatform, veler
 	return err
 }
 
+func readBaseKibishiiImage(kibishiiFilePath string) string {
+	bytes, err := os.ReadFile(kibishiiFilePath)
+	if err != nil {
+		return ""
+	}
+
+	sts := &appsv1api.StatefulSet{}
+	if err := yaml.UnmarshalStrict(bytes, sts); err != nil {
+		return ""
+	}
+
+	kibishiiImage := ""
+	if len(sts.Spec.Template.Spec.Containers) > 0 {
+		kibishiiImage = sts.Spec.Template.Spec.Containers[0].Image
+	}
+
+	return kibishiiImage
+}
+
+func readBaseJumpPadImage(jumpPadFilePath string) string {
+	bytes, err := os.ReadFile(jumpPadFilePath)
+	if err != nil {
+		return ""
+	}
+
+	pod := &corev1api.Pod{}
+	if err := yaml.UnmarshalStrict(bytes, pod); err != nil {
+		return ""
+	}
+
+	jumpPadImage := ""
+	if len(pod.Spec.Containers) > 0 {
+		jumpPadImage = pod.Spec.Containers[0].Image
+	}
+
+	return jumpPadImage
+}
+
+type patchImageData struct {
+	Image string
+}
+
+func generateKibishiiImagePatch(kibishiiImage string, patchDirectory string) error {
+	patchString := `
+apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
+kind: StatefulSet
+metadata:
+  name: kibishii-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - name: kibishii
+        image: {{.Image}}
+`
+
+	file, err := os.OpenFile(patchDirectory, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
+	defer file.Close()
+
+	if err != nil {
+		return err
+	}
+
+	patchTemplate, err := template.New("imagePatch").Parse(patchString)
+	if err != nil {
+		return err
+	}
+
+	if err := patchTemplate.Execute(file, patchImageData{Image: kibishiiImage}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func generateJumpPadPatch(jumpPadImage string, patchDirectory string) error {
+	patchString := `
+apiVersion: v1
+kind: Pod
+metadata:
+  name: jump-pad
+spec:
+  containers:
+    - name: jump-pad
+      image: {{.Image}}
+`
+	file, err := os.OpenFile(patchDirectory, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
+	defer file.Close()
+
+	if err != nil {
+		return err
+	}
+
+	patchTemplate, err := template.New("imagePatch").Parse(patchString)
+	if err != nil {
+		return err
+	}
+
+	if err := patchTemplate.Execute(file, patchImageData{Image: jumpPadImage}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func generateData(ctx context.Context, namespace string, kibishiiData *KibishiiData) error {
 	timeout := 30 * time.Minute
 	interval := 1 * time.Second
-	err := wait.PollImmediate(interval, timeout, func() (bool, error) {
+	err := wait.PollUntilContextTimeout(ctx, interval, timeout, true, func(ctx context.Context) (bool, error) {
 		timeout, ctxCancel := context.WithTimeout(context.Background(), time.Minute*20)
 		defer ctxCancel()
-		kibishiiGenerateCmd := exec.CommandContext(timeout, "kubectl", "exec", "-n", namespace, "jump-pad", "--",
-			"/usr/local/bin/generate.sh", strconv.Itoa(kibishiiData.Levels), strconv.Itoa(kibishiiData.DirsPerLevel),
-			strconv.Itoa(kibishiiData.FilesPerLevel), strconv.Itoa(kibishiiData.FileLength),
-			strconv.Itoa(kibishiiData.BlockSize), strconv.Itoa(kibishiiData.PassNum), strconv.Itoa(kibishiiData.ExpectedNodes))
+		kibishiiGenerateCmd := exec.CommandContext(
+			timeout,
+			"kubectl",
+			"exec",
+			"-n",
+			namespace,
+			"jump-pad",
+			"--",
+			"/usr/local/bin/generate.sh",
+			strconv.Itoa(kibishiiData.Levels),
+			strconv.Itoa(kibishiiData.DirsPerLevel),
+			strconv.Itoa(kibishiiData.FilesPerLevel),
+			strconv.Itoa(kibishiiData.FileLength),
+			strconv.Itoa(kibishiiData.BlockSize),
+			strconv.Itoa(kibishiiData.PassNum),
+			strconv.Itoa(kibishiiData.ExpectedNodes),
+		)
 		fmt.Printf("kibishiiGenerateCmd cmd =%v\n", kibishiiGenerateCmd)
 
 		stdout, stderr, err := veleroexec.RunCommand(kibishiiGenerateCmd)
@@ -342,26 +503,44 @@ func generateData(ctx context.Context, namespace string, kibishiiData *KibishiiD
 func verifyData(ctx context.Context, namespace string, kibishiiData *KibishiiData) error {
 	timeout := 10 * time.Minute
 	interval := 5 * time.Second
-	err := wait.PollImmediate(interval, timeout, func() (bool, error) {
-		timeout, ctxCancel := context.WithTimeout(context.Background(), time.Minute*20)
-		defer ctxCancel()
-		kibishiiVerifyCmd := exec.CommandContext(timeout, "kubectl", "exec", "-n", namespace, "jump-pad", "--",
-			"/usr/local/bin/verify.sh", strconv.Itoa(kibishiiData.Levels), strconv.Itoa(kibishiiData.DirsPerLevel),
-			strconv.Itoa(kibishiiData.FilesPerLevel), strconv.Itoa(kibishiiData.FileLength),
-			strconv.Itoa(kibishiiData.BlockSize), strconv.Itoa(kibishiiData.PassNum),
-			strconv.Itoa(kibishiiData.ExpectedNodes))
-		fmt.Printf("kibishiiVerifyCmd cmd =%v\n", kibishiiVerifyCmd)
+	err := wait.PollUntilContextTimeout(
+		ctx,
+		interval,
+		timeout,
+		true,
+		func(ctx context.Context) (bool, error) {
+			timeout, ctxCancel := context.WithTimeout(context.Background(), time.Minute*20)
+			defer ctxCancel()
+			kibishiiVerifyCmd := exec.CommandContext(
+				timeout,
+				"kubectl",
+				"exec",
+				"-n",
+				namespace,
+				"jump-pad",
+				"--",
+				"/usr/local/bin/verify.sh",
+				strconv.Itoa(kibishiiData.Levels),
+				strconv.Itoa(kibishiiData.DirsPerLevel),
+				strconv.Itoa(kibishiiData.FilesPerLevel),
+				strconv.Itoa(kibishiiData.FileLength),
+				strconv.Itoa(kibishiiData.BlockSize),
+				strconv.Itoa(kibishiiData.PassNum),
+				strconv.Itoa(kibishiiData.ExpectedNodes),
+			)
+			fmt.Printf("kibishiiVerifyCmd cmd =%v\n", kibishiiVerifyCmd)
 
-		stdout, stderr, err := veleroexec.RunCommand(kibishiiVerifyCmd)
-		if strings.Contains(stderr, "Timeout occurred") {
-			return false, nil
-		}
-		if err != nil {
-			fmt.Printf("Kibishi verify stdout Timeout occurred: %s stderr: %s err: %s\n", stdout, stderr, err)
-			return false, nil
-		}
-		return true, nil
-	})
+			stdout, stderr, err := veleroexec.RunCommand(kibishiiVerifyCmd)
+			if strings.Contains(stderr, "Timeout occurred") {
+				return false, nil
+			}
+			if err != nil {
+				fmt.Printf("Kibishi verify stdout Timeout occurred: %s stderr: %s err: %s\n", stdout, stderr, err)
+				return false, nil
+			}
+			return true, nil
+		},
+	)
 
 	if err != nil {
 		return errors.Wrapf(err, "Failed to verify kibishii data in namespace %s\n", namespace)
@@ -371,7 +550,12 @@ func verifyData(ctx context.Context, namespace string, kibishiiData *KibishiiDat
 }
 
 func waitForKibishiiPods(ctx context.Context, client TestClient, kibishiiNamespace string) error {
-	return WaitForPods(ctx, client, kibishiiNamespace, []string{"jump-pad", "etcd0", "etcd1", "etcd2", "kibishii-deployment-0", "kibishii-deployment-1"})
+	return WaitForPods(
+		ctx,
+		client,
+		kibishiiNamespace,
+		[]string{"jump-pad", "etcd0", "etcd1", "etcd2", "kibishii-deployment-0", "kibishii-deployment-1"},
+	)
 }
 
 func KibishiiGenerateData(oneHourTimeout context.Context, kibishiiNamespace string, kibishiiData *KibishiiData) error {
@@ -383,9 +567,17 @@ func KibishiiGenerateData(oneHourTimeout context.Context, kibishiiNamespace stri
 	return nil
 }
 
-func KibishiiPrepareBeforeBackup(oneHourTimeout context.Context, client TestClient,
-	providerName, kibishiiNamespace, registryCredentialFile, veleroFeatures,
-	kibishiiDirectory string, useVolumeSnapshots bool, kibishiiData *KibishiiData) error {
+func KibishiiPrepareBeforeBackup(
+	oneHourTimeout context.Context,
+	client TestClient,
+	providerName,
+	kibishiiNamespace,
+	registryCredentialFile,
+	veleroFeatures,
+	kibishiiDirectory string,
+	kibishiiData *KibishiiData,
+	imageRegistryProxy string,
+) error {
 	fmt.Printf("installKibishii %s\n", time.Now().Format("2006-01-02 15:04:05"))
 	serviceAccountName := "default"
 
@@ -399,8 +591,15 @@ func KibishiiPrepareBeforeBackup(oneHourTimeout context.Context, client TestClie
 		return errors.Wrapf(err, "failed to patch the service account %q under the namespace %q", serviceAccountName, kibishiiNamespace)
 	}
 
-	if err := installKibishii(oneHourTimeout, kibishiiNamespace, providerName, veleroFeatures,
-		kibishiiDirectory, useVolumeSnapshots, kibishiiData.ExpectedNodes); err != nil {
+	if err := installKibishii(
+		oneHourTimeout,
+		kibishiiNamespace,
+		providerName,
+		veleroFeatures,
+		kibishiiDirectory,
+		kibishiiData.ExpectedNodes,
+		imageRegistryProxy,
+	); err != nil {
 		return errors.Wrap(err, "Failed to install Kibishii workload")
 	}
 	// wait for kibishii pod startup

test/util/velero/install.go

@@ -390,7 +390,10 @@ func installVeleroServer(ctx context.Context, cli, cloudProvider string, options
 	if options.ItemBlockWorkerCount > 1 {
 		args = append(args, fmt.Sprintf("--item-block-worker-count=%d", options.ItemBlockWorkerCount))
 	}
-	args = append(args, fmt.Sprintf("--backup-repository-configmap=%s", test.BackupRepositoryConfigName))
+
+	if options.BackupRepoConfigMap != "" {
+		args = append(args, fmt.Sprintf("--backup-repository-configmap=%s", options.BackupRepoConfigMap))
+	}
 
 	if err := createVeleroResources(ctx, cli, namespace, args, options); err != nil {
 		return err

test/util/velero/velero_utils.go

@@ -61,7 +61,7 @@ var ImagesMatrix = map[string]map[string][]string{
 	"v1.13": {
 		"aws":                   {"velero/velero-plugin-for-aws:v1.9.2"},
 		"azure":                 {"velero/velero-plugin-for-microsoft-azure:v1.9.2"},
-		"vsphere":               {"velero/velero-plugin-for-vsphere:v1.5.2"},
+		"vsphere":               {"vsphereveleroplugin/velero-plugin-for-vsphere:v1.5.2"},
 		"gcp":                   {"velero/velero-plugin-for-gcp:v1.9.2"},
 		"csi":                   {"velero/velero-plugin-for-csi:v0.7.1"},
 		"datamover":             {"velero/velero-plugin-for-aws:v1.9.2"},
@@ -71,7 +71,7 @@ var ImagesMatrix = map[string]map[string][]string{
 	"v1.14": {
 		"aws":                   {"velero/velero-plugin-for-aws:v1.10.1"},
 		"azure":                 {"velero/velero-plugin-for-microsoft-azure:v1.10.1"},
-		"vsphere":               {"velero/velero-plugin-for-vsphere:v1.5.2"},
+		"vsphere":               {"vsphereveleroplugin/velero-plugin-for-vsphere:v1.5.2"},
 		"gcp":                   {"velero/velero-plugin-for-gcp:v1.10.1"},
 		"datamover":             {"velero/velero-plugin-for-aws:v1.10.1"},
 		"velero":                {"velero/velero:v1.14.1"},
@@ -80,7 +80,7 @@ var ImagesMatrix = map[string]map[string][]string{
 	"v1.15": {
 		"aws":                   {"velero/velero-plugin-for-aws:v1.11.0"},
 		"azure":                 {"velero/velero-plugin-for-microsoft-azure:v1.11.0"},
-		"vsphere":               {"velero/velero-plugin-for-vsphere:v1.5.2"},
+		"vsphere":               {"vsphereveleroplugin/velero-plugin-for-vsphere:v1.5.2"},
 		"gcp":                   {"velero/velero-plugin-for-gcp:v1.11.0"},
 		"datamover":             {"velero/velero-plugin-for-aws:v1.11.0"},
 		"velero":                {"velero/velero:v1.15.2"},
@@ -89,7 +89,7 @@ var ImagesMatrix = map[string]map[string][]string{
 	"v1.16": {
 		"aws":                   {"velero/velero-plugin-for-aws:v1.12.0"},
 		"azure":                 {"velero/velero-plugin-for-microsoft-azure:v1.12.0"},
-		"vsphere":               {"velero/velero-plugin-for-vsphere:v1.5.2"},
+		"vsphere":               {"vsphereveleroplugin/velero-plugin-for-vsphere:v1.5.2"},
 		"gcp":                   {"velero/velero-plugin-for-gcp:v1.12.0"},
 		"datamover":             {"velero/velero-plugin-for-aws:v1.12.0"},
 		"velero":                {"velero/velero:v1.15.0"},
@@ -98,7 +98,7 @@ var ImagesMatrix = map[string]map[string][]string{
 	"main": {
 		"aws":                   {"velero/velero-plugin-for-aws:main"},
 		"azure":                 {"velero/velero-plugin-for-microsoft-azure:main"},
-		"vsphere":               {"velero/velero-plugin-for-vsphere:v1.5.2"},
+		"vsphere":               {"vsphereveleroplugin/velero-plugin-for-vsphere:v1.5.2"},
 		"gcp":                   {"velero/velero-plugin-for-gcp:main"},
 		"datamover":             {"velero/velero-plugin-for-aws:main"},
 		"velero":                {"velero/velero:main"},
@@ -106,6 +106,17 @@ var ImagesMatrix = map[string]map[string][]string{
 	},
 }
 
+// UpdateImagesMatrixByProxy is used to append the proxy to the image lists.
+func UpdateImagesMatrixByProxy(imageRegistryProxy string) {
+	if imageRegistryProxy != "" {
+		for i := range ImagesMatrix {
+			for j := range ImagesMatrix[i] {
+				ImagesMatrix[i][j][0] = path.Join(imageRegistryProxy, ImagesMatrix[i][j][0])
+			}
+		}
+	}
+}
+
 func SetImagesToDefaultValues(config VeleroConfig, version string) (VeleroConfig, error) {
 	fmt.Printf("Get the images for version %s\n", version)
 
@@ -121,12 +132,6 @@ func SetImagesToDefaultValues(config VeleroConfig, version string) (VeleroConfig
 			versionWithoutPatch)
 	}
 
-	if config.ImageRegistryProxy != "" {
-		for index := range images {
-			images[index][0] = path.Join(config.ImageRegistryProxy, images[index][0])
-		}
-	}
-
 	ret.VeleroImage = images[Velero][0]
 	ret.RestoreHelperImage = images[VeleroRestoreHelper][0]
 
@@ -157,7 +162,7 @@ func SetImagesToDefaultValues(config VeleroConfig, version string) (VeleroConfig
 	return ret, nil
 }
 
-func getPluginsByVersion(version string, cloudProvider string, needDataMoverPlugin bool, imageRegistryProxy string) ([]string, error) {
+func getPluginsByVersion(version string, cloudProvider string, needDataMoverPlugin bool) ([]string, error) {
 	var cloudMap map[string][]string
 	arr := strings.Split(version, ".")
 	if len(arr) >= 3 {
@@ -172,12 +177,6 @@ func getPluginsByVersion(version string, cloudProvider string, needDataMoverPlug
 	var plugins []string
 	var ok bool
 
-	if imageRegistryProxy != "" {
-		for index := range cloudMap {
-			cloudMap[index][0] = path.Join(imageRegistryProxy, cloudMap[index][0])
-		}
-	}
-
 	if slices.Contains(LocalCloudProviders, cloudProvider) {
 		plugins, ok = cloudMap[AWS]
 		if !ok {
@@ -666,7 +665,6 @@ func GetPlugins(ctx context.Context, veleroCfg VeleroConfig, defaultBSL bool) ([
 	cloudProvider := veleroCfg.CloudProvider
 	objectStoreProvider := veleroCfg.ObjectStoreProvider
 	providerPlugins := veleroCfg.Plugins
-	imageRegistryProxy := veleroCfg.ImageRegistryProxy
 	needDataMoverPlugin := false
 	var plugins []string
 
@@ -685,9 +683,9 @@ func GetPlugins(ctx context.Context, veleroCfg VeleroConfig, defaultBSL bool) ([
 				return []string{}, errors.New("AdditionalBSLProvider should be provided.")
 			}
 
-			plugins, err = getPluginsByVersion(version, cloudProvider, false, imageRegistryProxy)
+			plugins, err = getPluginsByVersion(version, veleroCfg.AdditionalBSLProvider, false)
 			if err != nil {
-				return nil, errors.WithMessagef(err, "Fail to get plugin by provider %s and version %s", cloudProvider, version)
+				return nil, errors.WithMessagef(err, "Fail to get plugin by provider %s and version %s", veleroCfg.AdditionalBSLProvider, version)
 			}
 		} else {
 			plugins = append(plugins, veleroCfg.AddBSLPlugins)
@@ -715,7 +713,7 @@ func GetPlugins(ctx context.Context, veleroCfg VeleroConfig, defaultBSL bool) ([
 			needDataMoverPlugin = true
 		}
 
-		plugins, err = getPluginsByVersion(version, cloudProvider, needDataMoverPlugin, imageRegistryProxy)
+		plugins, err = getPluginsByVersion(version, cloudProvider, needDataMoverPlugin)
 		if err != nil {
 			return nil, errors.WithMessagef(err, "Fail to get plugin by provider %s and version %s", objectStoreProvider, version)
 		}