fix contexts

git-hyagi · git-hyagi · commit 30115eed9c30 · 2025-04-14T08:57:47.000-03:00
diff --git a/controllers/backup/configmap.go b/controllers/backup/configmap.go
@@ -79,7 +79,7 @@ func (r *RepoManagerBackupReconciler) createConfigMapBackupFile(ctx context.Cont
 	execCmd := []string{
 		"bash", "-c", fmt.Sprintf("cat<<EOF> %s/%s \n%sEOF", configMapType.backupDir, configMapType.backupFile, configMapYaml.String()),
 	}
-	_, err = controllers.ContainerExec(r, configMapType.pod, execCmd, configMapType.pulpBackup.Name+"-backup-manager", configMapType.pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, configMapType.pod, execCmd, configMapType.pulpBackup.Name+"-backup-manager", configMapType.pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to backup "+configMapType.configMapName+" configmap")
 		return err
diff --git a/controllers/backup/controller.go b/controllers/backup/controller.go
@@ -96,7 +96,7 @@ func (r *RepoManagerBackupReconciler) Reconcile(ctx context.Context, req ctrl.Re
 		return ctrl.Result{}, err
 	}
 
-	if err = r.createBackupDir(pulpBackup, backupDir, pod); err != nil {
+	if err = r.createBackupDir(ctx, pulpBackup, backupDir, pod); err != nil {
 		r.updateStatus(ctx, pulpBackup, metav1.ConditionFalse, "BackupComplete", "Failed to create backup directory!", "FailedCreateBkpDir")
 		return ctrl.Result{}, err
 	}
diff --git a/controllers/backup/cr.go b/controllers/backup/cr.go
@@ -30,7 +30,7 @@ func (r *RepoManagerBackupReconciler) backupCR(ctx context.Context, pulpBackup *
 	execCmd := []string{
 		"bash", "-c", "echo '" + string(pulpSpec) + "' > " + backupDir + "/cr_object",
 	}
-	_, err = controllers.ContainerExec(r, pod, execCmd, pulpBackup.Name+"-backup-manager", pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, pod, execCmd, pulpBackup.Name+"-backup-manager", pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to backup Pulp CR")
 		return err
diff --git a/controllers/backup/database.go b/controllers/backup/database.go
@@ -18,14 +18,14 @@ func (r *RepoManagerBackupReconciler) backupDatabase(ctx context.Context, pulpBa
 
 	log.Info("Starting database backup process ...")
 	execCmd := []string{"touch", backupDir + "/" + backupFile}
-	_, err := controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+	_, err := controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to create pulp.db backup file")
 		return err
 	}
 
 	execCmd = []string{"chmod", "0600", backupDir + "/" + backupFile}
-	_, err = controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to modify backup file permissions")
 		return err
@@ -43,7 +43,7 @@ func (r *RepoManagerBackupReconciler) backupDatabase(ctx context.Context, pulpBa
 		"-f", backupDir + "/" + backupFile,
 	}
 
-	_, err = controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to run pg_dump")
 		return err
diff --git a/controllers/backup/pulp_dir.go b/controllers/backup/pulp_dir.go
@@ -26,7 +26,7 @@ func (r *RepoManagerBackupReconciler) backupPulpDir(ctx context.Context, pulpBac
 		execCmd := []string{
 			"mkdir", "-p", backupDir + "/pulp",
 		}
-		_, err := controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+		_, err := controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 		if err != nil {
 			log.Error(err, "Failed to create pulp backup dir")
 			return err
@@ -35,7 +35,7 @@ func (r *RepoManagerBackupReconciler) backupPulpDir(ctx context.Context, pulpBac
 		execCmd = []string{
 			"bash", "-c", "cp -fa /var/lib/pulp/. " + backupDir + "/pulp",
 		}
-		_, err = controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+		_, err = controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 		if err != nil {
 			log.Error(err, "Failed to backup pulp dir")
 			return err
diff --git a/controllers/backup/secret.go b/controllers/backup/secret.go
@@ -162,7 +162,7 @@ func (r *RepoManagerBackupReconciler) createBackupFile(ctx context.Context, secr
 	execCmd := []string{
 		"bash", "-c", "echo '" + string(secretSerialized) + "' > " + secretType.backupDir + "/" + secretType.backupFile,
 	}
-	_, err = controllers.ContainerExec(r, secretType.pod, execCmd, secretType.pulpBackup.Name+"-backup-manager", secretType.pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, secretType.pod, execCmd, secretType.pulpBackup.Name+"-backup-manager", secretType.pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to backup "+secretType.secretName+" secret")
 		return err
@@ -191,7 +191,7 @@ func (r *RepoManagerBackupReconciler) createSecretBackupFile(ctx context.Context
 	execCmd := []string{
 		"bash", "-c", "echo '" + secretYaml.String() + "' > " + secretType.backupDir + "/" + secretType.backupFile,
 	}
-	_, err = controllers.ContainerExec(r, secretType.pod, execCmd, secretType.pulpBackup.Name+"-backup-manager", secretType.pod.Namespace)
+	_, err = controllers.ContainerExec(ctx, r, secretType.pod, execCmd, secretType.pulpBackup.Name+"-backup-manager", secretType.pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to backup "+secretType.secretName+" secret")
 		return err
diff --git a/controllers/backup/utils.go b/controllers/backup/utils.go
@@ -10,13 +10,13 @@ import (
 )
 
 // createBackupDir creates the directory to store the backup
-func (r *RepoManagerBackupReconciler) createBackupDir(pulpBackup *pulpv1.PulpBackup, backupDir string, pod *corev1.Pod) error {
+func (r *RepoManagerBackupReconciler) createBackupDir(ctx context.Context, pulpBackup *pulpv1.PulpBackup, backupDir string, pod *corev1.Pod) error {
 	log := r.RawLogger
 	backupPod := pulpBackup.Name + "-backup-manager"
 
 	log.Info("Creating backup folder ...")
 	execCmd := []string{"mkdir", "-p", backupDir}
-	_, err := controllers.ContainerExec(r, pod, execCmd, backupPod, pod.Namespace)
+	_, err := controllers.ContainerExec(ctx, r, pod, execCmd, backupPod, pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to create backup folder")
 		return err
diff --git a/controllers/deployment.go b/controllers/deployment.go
@@ -226,6 +226,7 @@ func (d *CommonDeployment) setTopologySpreadConstraints(pulp pulpv1.Pulp, pulpco
 func (d *CommonDeployment) setEnvVars(resources any, pulpcoreType settings.PulpcoreType) {
 	pulp := resources.(FunctionResources).Pulp
 	pulpcoreTypeField := reflect.ValueOf(pulp.Spec).FieldByName(string(pulpcoreType))
+	ctx := resources.(FunctionResources).Context
 
 	envVars := SetPulpcoreCustomEnvVars(*pulp, pulpcoreType)
 
@@ -323,7 +324,7 @@ func (d *CommonDeployment) setEnvVars(resources any, pulpcoreType settings.Pulpc
 	if pulp.Spec.SigningSecret != "" {
 
 		// for now, we are just dumping the error, but we should handle it
-		signingKeyFingerprint, _ := GetSigningKeyFingerprint(resources.(FunctionResources).Client, pulp.Spec.SigningSecret, pulp.Namespace)
+		signingKeyFingerprint, _ := GetSigningKeyFingerprint(ctx, resources.(FunctionResources).Client, pulp.Spec.SigningSecret, pulp.Namespace)
 
 		signingKeyEnvVars := []corev1.EnvVar{
 			{Name: "PULP_SIGNING_KEY_FINGERPRINT", Value: signingKeyFingerprint},
@@ -744,6 +745,7 @@ func (d *CommonDeployment) setInitContainerResourceRequirements(pulp pulpv1.Pulp
 // setReadinessProbe defines the container readinessprobe
 func (d *CommonDeployment) setReadinessProbe(resources any, pulp pulpv1.Pulp, pulpcoreType settings.PulpcoreType) {
 	readinessProbe := reflect.ValueOf(pulp.Spec).FieldByName(string(pulpcoreType)).FieldByName("ReadinessProbe").Interface().(*corev1.Probe)
+	ctx := resources.(FunctionResources).Context
 	switch pulpcoreType {
 	case settings.API:
 		if readinessProbe == nil {
@@ -752,7 +754,7 @@ func (d *CommonDeployment) setReadinessProbe(resources any, pulp pulpv1.Pulp, pu
 					Exec: &corev1.ExecAction{
 						Command: []string{
 							"/usr/bin/readyz.py",
-							GetAPIRoot(resources.(FunctionResources).Client, &pulp) + "api/v3/status/",
+							GetAPIRoot(ctx, resources.(FunctionResources).Client, &pulp) + "api/v3/status/",
 						},
 					},
 				},
@@ -770,7 +772,7 @@ func (d *CommonDeployment) setReadinessProbe(resources any, pulp pulpv1.Pulp, pu
 					Exec: &corev1.ExecAction{
 						Command: []string{
 							"/usr/bin/readyz.py",
-							GetContentPathPrefix(resources.(FunctionResources).Client, &pulp),
+							GetContentPathPrefix(ctx, resources.(FunctionResources).Client, &pulp),
 						},
 					},
 				},
@@ -806,14 +808,15 @@ func (d *CommonDeployment) setReadinessProbe(resources any, pulp pulpv1.Pulp, pu
 // setReadinessProbe defines the container livenessprobe
 func (d *CommonDeployment) setLivenessProbe(resources any, pulp pulpv1.Pulp, pulpcoreType settings.PulpcoreType) {
 	livenessProbe := reflect.ValueOf(pulp.Spec).FieldByName(string(pulpcoreType)).FieldByName("LivenessProbe").Interface().(*corev1.Probe)
+	ctx := resources.(FunctionResources).Context
 	switch pulpcoreType {
 	case settings.API:
 		if livenessProbe == nil {
 			livenessProbe = &corev1.Probe{
 				FailureThreshold: 10,
 				ProbeHandler: corev1.ProbeHandler{
 					HTTPGet: &corev1.HTTPGetAction{
-						Path: GetAPIRoot(resources.(FunctionResources).Client, &pulp) + "api/v3/status/",
+						Path: GetAPIRoot(ctx, resources.(FunctionResources).Client, &pulp) + "api/v3/status/",
 						Port: intstr.IntOrString{
 							IntVal: 24817,
 						},
@@ -887,6 +890,7 @@ func (d *CommonDeployment) setInitContainers(resources any, pulp pulpv1.Pulp, pu
 
 // setGpgInitContainer returns the definition of a container used to store the gpg keys in the keyring
 func setGpgInitContainer(resources any, pulp pulpv1.Pulp) corev1.Container {
+	ctx := resources.(FunctionResources).Context
 	volumeMounts := []corev1.VolumeMount{
 		{
 			Name:      "gpg-keys",
@@ -922,7 +926,7 @@ func setGpgInitContainer(resources any, pulp pulpv1.Pulp) corev1.Container {
 		},
 	}
 
-	signingKeyFingerprint, _ := GetSigningKeyFingerprint(resources.(FunctionResources).Client, pulp.Spec.SigningSecret, pulp.Namespace)
+	signingKeyFingerprint, _ := GetSigningKeyFingerprint(ctx, resources.(FunctionResources).Client, pulp.Spec.SigningSecret, pulp.Namespace)
 
 	// env vars
 	envVars := []corev1.EnvVar{{Name: "PULP_SIGNING_KEY_FINGERPRINT", Value: signingKeyFingerprint}}
diff --git a/controllers/ocp/route.go b/controllers/ocp/route.go
@@ -100,7 +100,7 @@ func PulpRouteController(resources controllers.FunctionResources, restClient res
 	execCmd := []string{
 		"/usr/bin/route_paths.py", pulp.Name,
 	}
-	cmdOutput, err := controllers.ContainerExec(PodExec{restClient, restConfig, resources.Scheme}, &pod, execCmd, "worker", pod.Namespace)
+	cmdOutput, err := controllers.ContainerExec(ctx, PodExec{restClient, restConfig, resources.Scheme}, &pod, execCmd, "worker", pod.Namespace)
 	if err != nil {
 		controllers.CustomZapLogger().Warn(err.Error() + " Failed to get routes from " + pod.Name)
 		controllers.UpdateStatus(ctx, resources.Client, pulp, metav1.ConditionFalse, conditionType, "Failed to get routes!", "FailedGet"+pod.Name)
@@ -111,13 +111,13 @@ func PulpRouteController(resources controllers.FunctionResources, restClient res
 	defaultPlugins := []RoutePlugin{
 		{
 			Name:        pulp.Name + "-content",
-			Path:        controllers.GetContentPathPrefix(resources.Client, pulp),
+			Path:        controllers.GetContentPathPrefix(ctx, resources.Client, pulp),
 			TargetPort:  "content-24816",
 			ServiceName: settings.ContentService(pulp.Name),
 		},
 		{
 			Name:        pulp.Name + "-api-v3",
-			Path:        controllers.GetAPIRoot(resources.Client, pulp) + "api/v3/",
+			Path:        controllers.GetAPIRoot(ctx, resources.Client, pulp) + "api/v3/",
 			TargetPort:  "api-24817",
 			ServiceName: settings.ApiService(pulp.Name),
 		},
diff --git a/controllers/repo_manager/ingress.go b/controllers/repo_manager/ingress.go
@@ -73,7 +73,7 @@ func (r *RepoManagerReconciler) pulpIngressController(ctx context.Context, pulp
 	execCmd := []string{
 		"/usr/bin/route_paths.py", pulp.Name,
 	}
-	cmdOutput, err := controllers.ContainerExec(r, &pod, execCmd, "content", pod.Namespace)
+	cmdOutput, err := controllers.ContainerExec(ctx, r, &pod, execCmd, "content", pod.Namespace)
 	if err != nil {
 		controllers.CustomZapLogger().Warn(err.Error() + " Failed to get ingresss from " + pod.Name)
 		controllers.UpdateStatus(ctx, r.Client, pulp, metav1.ConditionFalse, conditionType, "Failed to get ingresss!", "FailedGet"+pod.Name)
@@ -84,13 +84,13 @@ func (r *RepoManagerReconciler) pulpIngressController(ctx context.Context, pulp
 	defaultPlugins := []controllers.IngressPlugin{
 		{
 			Name:        pulp.Name + "-content",
-			Path:        controllers.GetContentPathPrefix(r.Client, pulp),
+			Path:        controllers.GetContentPathPrefix(ctx, r.Client, pulp),
 			TargetPort:  "content-24816",
 			ServiceName: settings.ContentService(pulp.Name),
 		},
 		{
 			Name:        pulp.Name + "-api-v3",
-			Path:        controllers.GetAPIRoot(r.Client, pulp) + "api/v3/",
+			Path:        controllers.GetAPIRoot(ctx, r.Client, pulp) + "api/v3/",
 			TargetPort:  "api-24817",
 			ServiceName: settings.ApiService(pulp.Name),
 		},
diff --git a/controllers/repo_manager/job.go b/controllers/repo_manager/job.go
@@ -346,7 +346,7 @@ func contentChecksumsModified(pulp *pulpv1.Pulp) bool {
 }
 
 // signingScriptContainer returns the definition of the container used in signingScript Job
-func signingScriptContainer(pulp *pulpv1.Pulp, scriptsSecret corev1.Secret, r RepoManagerReconciler) corev1.Container {
+func signingScriptContainer(ctx context.Context, pulp *pulpv1.Pulp, scriptsSecret corev1.Secret, r RepoManagerReconciler) corev1.Container {
 	// volume mounts
 	volumeMounts := pulpcoreVolumeMounts(pulp)
 	signingSecretMount := []corev1.VolumeMount{
@@ -398,7 +398,7 @@ func signingScriptContainer(pulp *pulpv1.Pulp, scriptsSecret corev1.Secret, r Re
 	// resource requirements
 	resources := pulp.Spec.SigningJob.PulpContainer.ResourceRequirements
 
-	fingerprint, _ := controllers.GetSigningKeyFingerprint(r.Client, pulp.Spec.SigningSecret, pulp.Namespace)
+	fingerprint, _ := controllers.GetSigningKeyFingerprint(ctx, r.Client, pulp.Spec.SigningSecret, pulp.Namespace)
 
 	// env vars
 	envVars := controllers.GetPostgresEnvVars(*pulp)
@@ -520,7 +520,7 @@ func (r *RepoManagerReconciler) signingScriptJob(ctx context.Context, pulp *pulp
 		labels,
 		&backoffLimit,
 		&jobTTL,
-		[]corev1.Container{signingScriptContainer(pulp, *secret, *r)},
+		[]corev1.Container{signingScriptContainer(ctx, pulp, *secret, *r)},
 		signingScriptJobVolumes(pulp, *secret),
 	})
 
diff --git a/controllers/repo_manager/precheck.go b/controllers/repo_manager/precheck.go
@@ -197,7 +197,7 @@ func checkRouteNotOCP(log logr.Logger, pulp *pulpv1.Pulp) *ctrl.Result {
 }
 
 // checkImmutableFields verifies if an immutable field had changed
-func checkImmutableFields(ctx context.Context, r *RepoManagerReconciler, pulp *pulpv1.Pulp) *ctrl.Result {
+/* func checkImmutableFields(ctx context.Context, r *RepoManagerReconciler, pulp *pulpv1.Pulp) *ctrl.Result {
 	// Checking immutable fields update
 	immutableFields := []immutableField{
 		{FieldName: "ObjectStorageAzureSecret", FieldPath: pulpv1.PulpSpec{}},
@@ -215,7 +215,7 @@ func checkImmutableFields(ctx context.Context, r *RepoManagerReconciler, pulp *p
 		}
 	}
 	return nil
-}
+} */
 
 // checkSecretsAvailability verifies if the secrets defined in Pulp CR are available.
 // If an expected secret is not found, the operator will fail early and
diff --git a/controllers/repo_manager/rbac.go b/controllers/repo_manager/rbac.go
@@ -18,7 +18,6 @@ package repo_manager
 
 import (
 	"context"
-	"reflect"
 	"regexp"
 
 	pulpv1 "github.com/pulp/pulp-operator/apis/repo-manager.pulpproject.org/v1"
@@ -237,8 +236,9 @@ func getApiConditionType() string {
 }
 
 // saModified returns true if some specific fields from a SA differs from the expected
-func saModified(currentSA, expectedSA *corev1.ServiceAccount) bool {
+/* func saModified(currentSA, expectedSA *corev1.ServiceAccount) bool {
 	return !reflect.DeepEqual(currentSA.ImagePullSecrets, expectedSA.ImagePullSecrets) ||
 		!reflect.DeepEqual(currentSA.ObjectMeta.Annotations, expectedSA.ObjectMeta.Annotations) ||
 		!reflect.DeepEqual(currentSA.ObjectMeta.Labels, expectedSA.ObjectMeta.Labels)
 }
+*/
diff --git a/controllers/repo_manager/utils.go b/controllers/repo_manager/utils.go
@@ -8,7 +8,6 @@ import (
 	"crypto/x509"
 	b64 "encoding/base64"
 	"encoding/pem"
-	"fmt"
 	"io"
 	"math/rand"
 	"reflect"
@@ -38,10 +37,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 )
 
-type immutableField struct {
+/* type immutableField struct {
 	FieldName string
 	FieldPath interface{}
 }
+*/
 
 // Generate a random string with length pwdSize
 func createPwd(pwdSize int) string {
@@ -153,7 +153,7 @@ func checkSecretsAvailable(funcResources controllers.FunctionResources) error {
 
 // checkImmutableFields verifies if a user tried to modify an immutable field and rollback
 // the change if so
-func (r *RepoManagerReconciler) checkImmutableFields(ctx context.Context, pulp *pulpv1.Pulp, field immutableField, log logr.Logger) bool {
+/* func (r *RepoManagerReconciler) checkImmutableFields(ctx context.Context, pulp *pulpv1.Pulp, field immutableField, log logr.Logger) bool {
 
 	fieldSpec := reflect.Value{}
 
@@ -191,7 +191,7 @@ func (r *RepoManagerReconciler) checkImmutableFields(ctx context.Context, pulp *
 		return true
 	}
 	return false
-}
+} */
 
 // updateIngressType will check the current definition of ingress_type and will handle the different
 // modification scenarios
diff --git a/controllers/repo_manager/web.go b/controllers/repo_manager/web.go
@@ -45,7 +45,7 @@ func (r *RepoManagerReconciler) pulpWebController(ctx context.Context, pulp *pul
 	configMapName := settings.PulpWebConfigMapName(pulp.Name)
 	webConfigMap := &corev1.ConfigMap{}
 	err := r.Get(ctx, types.NamespacedName{Name: configMapName, Namespace: pulp.Namespace}, webConfigMap)
-	newWebConfigMap := r.pulpWebConfigMap(pulp)
+	newWebConfigMap := r.pulpWebConfigMap(ctx, pulp)
 	if err != nil && errors.IsNotFound(err) {
 		log.Info("Creating a new Pulp Web ConfigMap", "ConfigMap.Namespace", newWebConfigMap.Namespace, "ConfigMap.Name", newWebConfigMap.Name)
 		controllers.UpdateStatus(ctx, r.Client, pulp, metav1.ConditionFalse, conditionType, "CreatingWebConfigmap", "Creating "+pulp.Name+"-web configmap resource")
@@ -142,6 +142,7 @@ func (r *RepoManagerReconciler) deploymentForPulpWeb(m *pulpv1.Pulp, funcResourc
 	replicas := m.Spec.Web.Replicas
 	resources := m.Spec.Web.ResourceRequirements
 	ImageWeb := os.Getenv("RELATED_IMAGE_PULP_WEB")
+	ctx := funcResources.Context
 	if len(m.Spec.ImageWeb) > 0 && len(m.Spec.ImageWebVersion) > 0 {
 		ImageWeb = m.Spec.ImageWeb + ":" + m.Spec.ImageWebVersion
 	} else if ImageWeb == "" {
@@ -162,7 +163,7 @@ func (r *RepoManagerReconciler) deploymentForPulpWeb(m *pulpv1.Pulp, funcResourc
 			FailureThreshold: 2,
 			ProbeHandler: corev1.ProbeHandler{
 				HTTPGet: &corev1.HTTPGetAction{
-					Path: controllers.GetAPIRoot(funcResources.Client, m) + "api/v3/status/",
+					Path: controllers.GetAPIRoot(ctx, funcResources.Client, m) + "api/v3/status/",
 					Port: intstr.IntOrString{
 						IntVal: 8080,
 					},
@@ -347,7 +348,7 @@ func serviceForPulpWeb(m *pulpv1.Pulp) *corev1.Service {
 }
 
 // wouldn't it be better to handle the configmap content by loading it from a file?
-func (r *RepoManagerReconciler) pulpWebConfigMap(m *pulpv1.Pulp) *corev1.ConfigMap {
+func (r *RepoManagerReconciler) pulpWebConfigMap(ctx context.Context, m *pulpv1.Pulp) *corev1.ConfigMap {
 
 	// Nginx default values
 	nginxProxyReadTimeout := m.Spec.NginxProxyReadTimeout
@@ -479,7 +480,7 @@ func (r *RepoManagerReconciler) pulpWebConfigMap(m *pulpv1.Pulp) *corev1.ConfigM
 				proxy_pass http://pulp-content;
 			}
 
-			location ` + controllers.GetAPIRoot(r.Client, m) + `api/v3/ {
+			location ` + controllers.GetAPIRoot(ctx, r.Client, m) + `api/v3/ {
 				proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 				proxy_set_header X-Forwarded-Proto $scheme;
 				proxy_set_header Host $http_host;
diff --git a/controllers/restore/configmap.go b/controllers/restore/configmap.go
@@ -33,7 +33,7 @@ func (r *RepoManagerRestoreReconciler) restoreConfigMapFromYaml(ctx context.Cont
 	execCmd := []string{
 		"test", "-f", configMapFile,
 	}
-	_, err := controllers.ContainerExec(r, pod, execCmd, pulpRestore.Name+"-backup-manager", pod.Namespace)
+	_, err := controllers.ContainerExec(ctx, r, pod, execCmd, pulpRestore.Name+"-backup-manager", pod.Namespace)
 
 	// if configmap is not found there is nothing to be restored
 	if err != nil {
@@ -42,7 +42,7 @@ func (r *RepoManagerRestoreReconciler) restoreConfigMapFromYaml(ctx context.Cont
 	execCmd = []string{
 		"cat", configMapFile,
 	}
-	cmdOutput, err := controllers.ContainerExec(r, pod, execCmd, pulpRestore.Name+"-backup-manager", pod.Namespace)
+	cmdOutput, err := controllers.ContainerExec(ctx, r, pod, execCmd, pulpRestore.Name+"-backup-manager", pod.Namespace)
 	if err != nil {
 		log.Error(err, "Failed to get "+backupFile+"!")
 		r.updateStatus(ctx, pulpRestore, metav1.ConditionFalse, "RestoreComplete", "Failed to get "+backupFile, "FailedGet"+resourceType+"ConfigMap")
diff --git a/controllers/restore/controller.go b/controllers/restore/controller.go
diff --git a/controllers/restore/database.go b/controllers/restore/database.go
diff --git a/controllers/restore/deploy.go b/controllers/restore/deploy.go
diff --git a/controllers/restore/pulp_dir.go b/controllers/restore/pulp_dir.go
diff --git a/controllers/restore/secret.go b/controllers/restore/secret.go
diff --git a/controllers/utils.go b/controllers/utils.go

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ func (r *RepoManagerBackupReconciler) createConfigMapBackupFile(ctx context.Cont`
`79`	`79`	`execCmd := []string{`
`80`	`80`	`"bash", "-c", fmt.Sprintf("cat<<EOF> %s/%s \n%sEOF", configMapType.backupDir, configMapType.backupFile, configMapYaml.String()),`
`81`	`81`	`}`
`82`		`- _, err = controllers.ContainerExec(r, configMapType.pod, execCmd, configMapType.pulpBackup.Name+"-backup-manager", configMapType.pod.Namespace)`
	`82`	`+ _, err = controllers.ContainerExec(ctx, r, configMapType.pod, execCmd, configMapType.pulpBackup.Name+"-backup-manager", configMapType.pod.Namespace)`
`83`	`83`	`if err != nil {`
`84`	`84`	`log.Error(err, "Failed to backup "+configMapType.configMapName+" configmap")`
`85`	`85`	`return err`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ func (r *RepoManagerBackupReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`96`	`96`	`return ctrl.Result{}, err`
`97`	`97`	`}`
`98`	`98`
`99`		`- if err = r.createBackupDir(pulpBackup, backupDir, pod); err != nil {`
	`99`	`+ if err = r.createBackupDir(ctx, pulpBackup, backupDir, pod); err != nil {`
`100`	`100`	`r.updateStatus(ctx, pulpBackup, metav1.ConditionFalse, "BackupComplete", "Failed to create backup directory!", "FailedCreateBkpDir")`
`101`	`101`	`return ctrl.Result{}, err`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ func (r RepoManagerBackupReconciler) backupCR(ctx context.Context, pulpBackup `
`30`	`30`	`execCmd := []string{`
`31`	`31`	`"bash", "-c", "echo '" + string(pulpSpec) + "' > " + backupDir + "/cr_object",`
`32`	`32`	`}`
`33`		`- _, err = controllers.ContainerExec(r, pod, execCmd, pulpBackup.Name+"-backup-manager", pod.Namespace)`
	`33`	`+ _, err = controllers.ContainerExec(ctx, r, pod, execCmd, pulpBackup.Name+"-backup-manager", pod.Namespace)`
`34`	`34`	`if err != nil {`
`35`	`35`	`log.Error(err, "Failed to backup Pulp CR")`
`36`	`36`	`return err`