mirrors/velero
1
0
Fork 0
mirror of https://github.com/vmware-tanzu/velero.git synced 2026-01-07 13:55:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Self contain context in each high level function rather than passing around in structs

Browse Source 
Signed-off-by: Tiger Kaovilai <tkaovila@redhat.com>
This commit is contained in:
Tiger Kaovilai
2023-04-16 13:59:21 -04:00
parent 3f4b258dee
commit d6848ffb16
24 changed files with 244 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
test/e2e/basic/resources-check/namespaces.go
View File

@@ -93,14 +93,15 @@ func (m *MultiNSBackup) StartRun() error {
}
func (m *MultiNSBackup) CreateResources() error {
m.Ctx, _ = context.WithTimeout(context.Background(), m.TimeoutDuration)
ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
defer ctxCancel()
fmt.Printf("Creating namespaces ...\n")
labels := map[string]string{
"ns-test": "true",
}
for nsNum := 0; nsNum < m.NamespacesTotal; nsNum++ {
createNSName := fmt.Sprintf("%s-%00000d", m.NSBaseName, nsNum)
if err := CreateNamespaceWithLabel(m.Ctx, m.Client, createNSName, labels); err != nil {
if err := CreateNamespaceWithLabel(ctx, m.Client, createNSName, labels); err != nil {
return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
}
}
@@ -108,10 +109,12 @@ func (m *MultiNSBackup) CreateResources() error {
}
func (m *MultiNSBackup) Verify() error {
ctx, ctxCancel := context.WithTimeout(context.Background(), m.TimeoutDuration)
defer ctxCancel()
// Verify that we got back all of the namespaces we created
for nsNum := 0; nsNum < m.NamespacesTotal; nsNum++ {
checkNSName := fmt.Sprintf("%s-%00000d", m.NSBaseName, nsNum)
checkNS, err := GetNamespace(m.Ctx, m.Client, checkNSName)
checkNS, err := GetNamespace(ctx, m.Client, checkNSName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
} else if checkNS.Name != checkNSName {
@@ -122,10 +125,11 @@ func (m *MultiNSBackup) Verify() error {
}
func (m *MultiNSBackup) Destroy() error {
m.Ctx, _ = context.WithTimeout(context.Background(), 60*time.Minute)
err := CleanupNamespaces(m.Ctx, m.Client, m.NSBaseName)
ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
defer ctxCancel()
err := CleanupNamespaces(ctx, m.Client, m.NSBaseName)
if err != nil {
return errors.Wrap(err, "Could cleanup retrieve namespaces")
}
return WaitAllSelectedNSDeleted(m.Ctx, m.Client, "ns-test=true")
return WaitAllSelectedNSDeleted(ctx, m.Client, "ns-test=true")
}

9
test/e2e/basic/resources-check/namespaces_annotation.go
View File

@@ -68,11 +68,12 @@ func (n *NSAnnotationCase) Init() error {
}
func (n *NSAnnotationCase) CreateResources() error {
n.Ctx, _ = context.WithTimeout(context.Background(), 10*time.Minute)
ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
defer ctxCancel()
for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
createNSName := fmt.Sprintf("%s-%00000d", n.NSBaseName, nsNum)
createAnnotationName := fmt.Sprintf("annotation-%s-%00000d", n.NSBaseName, nsNum)
if err := CreateNamespaceWithAnnotation(n.Ctx, n.Client, createNSName, map[string]string{"testAnnotation": createAnnotationName}); err != nil {
if err := CreateNamespaceWithAnnotation(ctx, n.Client, createNSName, map[string]string{"testAnnotation": createAnnotationName}); err != nil {
return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
}
}
@@ -80,10 +81,12 @@ func (n *NSAnnotationCase) CreateResources() error {
}
func (n *NSAnnotationCase) Verify() error {
ctx, ctxCancel := context.WithTimeout(context.Background(), 60*time.Minute)
defer ctxCancel()
for nsNum := 0; nsNum < n.NamespacesTotal; nsNum++ {
checkNSName := fmt.Sprintf("%s-%00000d", n.NSBaseName, nsNum)
checkAnnoName := fmt.Sprintf("annotation-%s-%00000d", n.NSBaseName, nsNum)
checkNS, err := GetNamespace(n.Ctx, n.Client, checkNSName)
checkNS, err := GetNamespace(ctx, n.Client, checkNSName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)

28
test/e2e/basic/resources-check/rbac.go
View File

@@ -84,21 +84,22 @@ func (r *RBACCase) Init() error {
}
func (r *RBACCase) CreateResources() error {
r.Ctx, _ = context.WithTimeout(context.Background(), 10*time.Minute)
ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer ctxCancel()
for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
createNSName := fmt.Sprintf("%s-%00000d", r.NSBaseName, nsNum)
fmt.Printf("Creating namespaces ...%s\n", createNSName)
if err := CreateNamespace(r.Ctx, r.Client, createNSName); err != nil {
if err := CreateNamespace(ctx, r.Client, createNSName); err != nil {
return errors.Wrapf(err, "Failed to create namespace %s", createNSName)
}
serviceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.NSBaseName, nsNum)
fmt.Printf("Creating service account ...%s\n", createNSName)
if err := CreateServiceAccount(r.Ctx, r.Client, createNSName, serviceAccountName); err != nil {
if err := CreateServiceAccount(ctx, r.Client, createNSName, serviceAccountName); err != nil {
return errors.Wrapf(err, "Failed to create service account %s", serviceAccountName)
}
clusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.NSBaseName, nsNum)
clusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.NSBaseName, nsNum)
if err := CreateRBACWithBindingSA(r.Ctx, r.Client, createNSName, serviceAccountName, clusterRoleName, clusterRoleBindingName); err != nil {
if err := CreateRBACWithBindingSA(ctx, r.Client, createNSName, serviceAccountName, clusterRoleName, clusterRoleBindingName); err != nil {
return errors.Wrapf(err, "Failed to create cluster role %s with role binding %s", clusterRoleName, clusterRoleBindingName)
}
}
@@ -106,13 +107,14 @@ func (r *RBACCase) CreateResources() error {
}
func (r *RBACCase) Verify() error {
ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer ctxCancel()
for nsNum := 0; nsNum < r.NamespacesTotal; nsNum++ {
checkNSName := fmt.Sprintf("%s-%00000d", r.NSBaseName, nsNum)
checkServiceAccountName := fmt.Sprintf("service-account-%s-%00000d", r.NSBaseName, nsNum)
checkClusterRoleName := fmt.Sprintf("clusterrole-%s-%00000d", r.NSBaseName, nsNum)
checkClusterRoleBindingName := fmt.Sprintf("clusterrolebinding-%s-%00000d", r.NSBaseName, nsNum)
checkNS, err := GetNamespace(r.Ctx, r.Client, checkNSName)
checkNS, err := GetNamespace(ctx, r.Client, checkNSName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test namespace %s", checkNSName)
}
@@ -121,7 +123,7 @@ func (r *RBACCase) Verify() error {
}
//getting service account from the restore
checkSA, err := GetServiceAccount(r.Ctx, r.Client, checkNSName, checkServiceAccountName)
checkSA, err := GetServiceAccount(ctx, r.Client, checkNSName, checkServiceAccountName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test service account %s", checkSA)
@@ -132,7 +134,7 @@ func (r *RBACCase) Verify() error {
}
//getting cluster role from the restore
checkClusterRole, err := GetClusterRole(r.Ctx, r.Client, checkClusterRoleName)
checkClusterRole, err := GetClusterRole(ctx, r.Client, checkClusterRoleName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test cluster role %s", checkClusterRole)
@@ -143,7 +145,7 @@ func (r *RBACCase) Verify() error {
}
//getting cluster role binding from the restore
checkClusterRoleBinding, err := GetClusterRoleBinding(r.Ctx, r.Client, checkClusterRoleBindingName)
checkClusterRoleBinding, err := GetClusterRoleBinding(ctx, r.Client, checkClusterRoleBindingName)
if err != nil {
return errors.Wrapf(err, "Could not retrieve test cluster role binding %s", checkClusterRoleBinding)
@@ -164,19 +166,21 @@ func (r *RBACCase) Verify() error {
}
func (r *RBACCase) Destroy() error {
ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer ctxCancel()
//cleanup clusterrole
err := CleanupClusterRole(r.Ctx, r.Client, r.NSBaseName)
err := CleanupClusterRole(ctx, r.Client, r.NSBaseName)
if err != nil {
return errors.Wrap(err, "Could not cleanup clusterroles")
}
//cleanup cluster rolebinding
err = CleanupClusterRoleBinding(r.Ctx, r.Client, r.NSBaseName)
err = CleanupClusterRoleBinding(ctx, r.Client, r.NSBaseName)
if err != nil {
return errors.Wrap(err, "Could not cleanup clusterrolebindings")
}
err = CleanupNamespacesWithPoll(r.Ctx, r.Client, r.NSBaseName)
err = CleanupNamespacesWithPoll(ctx, r.Client, r.NSBaseName)
if err != nil {
return errors.Wrap(err, "Could cleanup retrieve namespaces")
}