Set VCAP_APPLICATION env var in apps

Makefile

@@ -37,7 +37,7 @@ generate-fakes:
 
 fmt: install-gofumpt install-shfmt
 	$(GOFUMPT) -w .
-	$(SHFMT) -w -i 2 -ci .
+	$(SHFMT) -f . | grep -v '^tests/vendor' | xargs $(SHFMT) -w -i 2 -ci
 
 vet: ## Run go vet against code.
 	go vet ./...
@@ -69,3 +69,4 @@ install-vendir:
 
 vendir-update-dependencies: install-vendir
 	$(VENDIR) sync --chdir tests
+	cd tests/vendor/testApps/dora; zip -r ../../../e2e/assets/dora .

api/handlers/app_test.go

@@ -2596,6 +2596,7 @@ var _ = Describe("App", func() {
 				SpaceGUID:            spaceGUID,
 				EnvironmentVariables: map[string]string{"VAR": "VAL"},
 				SystemEnv:            map[string]interface{}{},
+				AppEnv:               map[string]interface{}{},
 			}, nil)
 
 			req = createHttpRequest("GET", "/v3/apps/"+appGUID+"/env", nil)

api/presenter/app.go

@@ -172,11 +172,11 @@ func ForAppEnvVars(record repositories.AppEnvVarsRecord, baseURL url.URL) AppEnv
 }
 
 type AppEnvResponse struct {
-	EnvironmentVariables map[string]string      `json:"environment_variables"`
-	StagingEnvJSON       map[string]string      `json:"staging_env_json"`
-	RunningEnvJSON       map[string]string      `json:"running_env_json"`
-	SystemEnvJSON        map[string]interface{} `json:"system_env_json"`
-	ApplicationEnvJSON   map[string]string      `json:"application_env_json"`
+	EnvironmentVariables map[string]string `json:"environment_variables"`
+	StagingEnvJSON       map[string]string `json:"staging_env_json"`
+	RunningEnvJSON       map[string]string `json:"running_env_json"`
+	SystemEnvJSON        map[string]any    `json:"system_env_json"`
+	ApplicationEnvJSON   map[string]any    `json:"application_env_json"`
 }
 
 func ForAppEnv(envVarRecord repositories.AppEnvRecord) AppEnvResponse {
@@ -185,6 +185,6 @@ func ForAppEnv(envVarRecord repositories.AppEnvRecord) AppEnvResponse {
 		StagingEnvJSON:       map[string]string{},
 		RunningEnvJSON:       map[string]string{},
 		SystemEnvJSON:        envVarRecord.SystemEnv,
-		ApplicationEnvJSON:   map[string]string{},
+		ApplicationEnvJSON:   envVarRecord.AppEnv,
 	}
 }

api/repositories/app_repository.go

@@ -75,6 +75,7 @@ type AppRecord struct {
 	IsStaged              bool
 	envSecretName         string
 	vcapServiceSecretName string
+	vcapAppSecretName     string
 }
 
 type DesiredState string
@@ -101,6 +102,7 @@ type AppEnvRecord struct {
 	SpaceGUID            string
 	EnvironmentVariables map[string]string
 	SystemEnv            map[string]interface{}
+	AppEnv               map[string]interface{}
 }
 
 type CurrentDropletRecord struct {
@@ -573,21 +575,43 @@ func (f *AppRepo) GetAppEnv(ctx context.Context, authInfo authorization.Info, ap
 		appEnvVarMap = convertByteSliceValuesToStrings(appEnvVarSecret.Data)
 	}
 
-	systemEnvMap := map[string]interface{}{}
+	systemEnvMap, err := getSystemEnv(ctx, userClient, app)
+	if err != nil {
+		return AppEnvRecord{}, err
+	}
+
+	appEnvMap, err := getAppEnv(ctx, userClient, app)
+	if err != nil {
+		return AppEnvRecord{}, err
+	}
+
+	appEnvRecord := AppEnvRecord{
+		AppGUID:              appGUID,
+		SpaceGUID:            app.SpaceGUID,
+		EnvironmentVariables: appEnvVarMap,
+		SystemEnv:            systemEnvMap,
+		AppEnv:               appEnvMap,
+	}
+
+	return appEnvRecord, nil
+}
+
+func getSystemEnv(ctx context.Context, userClient client.Client, app AppRecord) (map[string]any, error) {
+	systemEnvMap := map[string]any{}
 	if app.vcapServiceSecretName != "" {
 		vcapServiceSecret := new(corev1.Secret)
-		err = userClient.Get(ctx, types.NamespacedName{Name: app.vcapServiceSecretName, Namespace: app.SpaceGUID}, vcapServiceSecret)
+		err := userClient.Get(ctx, types.NamespacedName{Name: app.vcapServiceSecretName, Namespace: app.SpaceGUID}, vcapServiceSecret)
 		if err != nil {
-			return AppEnvRecord{}, fmt.Errorf("error finding VCAP Service Secret %q for App %q: %w",
+			return map[string]any{}, fmt.Errorf("error finding VCAP Service Secret %q for App %q: %w",
 				app.vcapServiceSecretName,
 				app.GUID,
 				apierrors.FromK8sError(err, AppEnvResourceType))
 		}
 
 		if vcapServicesData, ok := vcapServiceSecret.Data["VCAP_SERVICES"]; ok {
-			vcapServicesPresenter := new(env.VcapServicesPresenter)
+			vcapServicesPresenter := new(env.VCAPServices)
 			if err = json.Unmarshal(vcapServicesData, &vcapServicesPresenter); err != nil {
-				return AppEnvRecord{}, fmt.Errorf("error unmarshalling VCAP Service Secret %q for App %q: %w",
+				return map[string]any{}, fmt.Errorf("error unmarshalling VCAP Service Secret %q for App %q: %w",
 					app.vcapServiceSecretName,
 					app.GUID,
 					apierrors.FromK8sError(err, AppEnvResourceType))
@@ -599,14 +623,34 @@ func (f *AppRepo) GetAppEnv(ctx context.Context, authInfo authorization.Info, ap
 		}
 	}
 
-	appEnvRecord := AppEnvRecord{
-		AppGUID:              appGUID,
-		SpaceGUID:            app.SpaceGUID,
-		EnvironmentVariables: appEnvVarMap,
-		SystemEnv:            systemEnvMap,
+	return systemEnvMap, nil
+}
+
+func getAppEnv(ctx context.Context, userClient client.Client, app AppRecord) (map[string]any, error) {
+	appEnvMap := map[string]any{}
+	if app.vcapAppSecretName != "" {
+		vcapAppSecret := new(corev1.Secret)
+		err := userClient.Get(ctx, types.NamespacedName{Name: app.vcapAppSecretName, Namespace: app.SpaceGUID}, vcapAppSecret)
+		if err != nil {
+			return map[string]any{}, fmt.Errorf("error finding VCAP Application Secret %q for App %q: %w",
+				app.vcapAppSecretName,
+				app.GUID,
+				apierrors.FromK8sError(err, AppEnvResourceType))
+		}
+
+		if vcapAppDataBytes, ok := vcapAppSecret.Data["VCAP_APPLICATION"]; ok {
+			appData := map[string]any{}
+			if err = json.Unmarshal(vcapAppDataBytes, &appData); err != nil {
+				return map[string]any{}, fmt.Errorf("error unmarshalling VCAP Application Secret %q for App %q: %w",
+					app.vcapAppSecretName,
+					app.GUID,
+					apierrors.FromK8sError(err, AppEnvResourceType))
+			}
+			appEnvMap["VCAP_APPLICATION"] = appData
+		}
 	}
 
-	return appEnvRecord, nil
+	return appEnvMap, nil
 }
 
 func GenerateEnvSecretName(appGUID string) string {
@@ -684,6 +728,7 @@ func cfAppToAppRecord(cfApp korifiv1alpha1.CFApp) AppRecord {
 		IsStaged:              meta.IsStatusConditionTrue(cfApp.Status.Conditions, workloads.StatusConditionStaged),
 		envSecretName:         cfApp.Spec.EnvSecretName,
 		vcapServiceSecretName: cfApp.Status.VCAPServicesSecretName,
+		vcapAppSecretName:     cfApp.Status.VCAPApplicationSecretName,
 	}
 }
 

api/repositories/app_repository_test.go

@@ -1352,13 +1352,14 @@ var _ = Describe("AppRepository", func() {
 				Expect(appEnvRecord.SpaceGUID).To(Equal(cfApp.Namespace))
 				Expect(appEnvRecord.EnvironmentVariables).To(Equal(envVars))
 				Expect(appEnvRecord.SystemEnv).To(BeEmpty())
+				Expect(appEnvRecord.AppEnv).To(BeEmpty())
 			})
 
 			When("the app has a service-binding secret", func() {
 				var (
 					vcapServiceSecretDataByte map[string][]byte
 					vcapServiceSecretData     map[string]string
-					vcapServiceDataPresenter  *env.VcapServicesPresenter
+					vcapServiceDataPresenter  *env.VCAPServices
 					err                       error
 				)
 
@@ -1367,7 +1368,7 @@ var _ = Describe("AppRepository", func() {
 					vcapServiceSecretDataByte, err = generateVcapServiceSecretDataByte()
 					Expect(err).NotTo(HaveOccurred())
 					vcapServiceSecretData = asMapOfStrings(vcapServiceSecretDataByte)
-					vcapServiceDataPresenter = new(env.VcapServicesPresenter)
+					vcapServiceDataPresenter = new(env.VCAPServices)
 					err = json.Unmarshal(vcapServiceSecretDataByte["VCAP_SERVICES"], vcapServiceDataPresenter)
 					Expect(err).NotTo(HaveOccurred())
 
@@ -1441,6 +1442,31 @@ var _ = Describe("AppRepository", func() {
 				})
 			})
 
+			When("the app has a vcap application secret", func() {
+				BeforeEach(func() {
+					vcapAppSecretName := prefixedGUID("vcap-app-secret")
+					Expect(k8sClient.Create(ctx, &corev1.Secret{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:      vcapAppSecretName,
+							Namespace: cfApp.Namespace,
+						},
+						Data: map[string][]byte{
+							"VCAP_APPLICATION": []byte(`{"foo":"bar"}`),
+						},
+					})).To(Succeed())
+					Expect(k8s.Patch(ctx, k8sClient, cfApp, func() {
+						cfApp.Status.VCAPApplicationSecretName = vcapAppSecretName
+					})).To(Succeed())
+				})
+
+				It("returns the env vars stored on the secret", func() {
+					Expect(getAppEnvErr).NotTo(HaveOccurred())
+					Expect(appEnvRecord.EnvironmentVariables).To(Equal(envVars))
+
+					Expect(appEnvRecord.AppEnv).To(HaveKey("VCAP_APPLICATION"))
+				})
+			})
+
 			When("the EnvSecret doesn't exist", func() {
 				BeforeEach(func() {
 					secretName = "doIReallyExist"
@@ -1467,6 +1493,20 @@ var _ = Describe("AppRepository", func() {
 					Expect(getAppEnvErr).To(MatchError(ContainSubstring("Secret")))
 				})
 			})
+
+			When("the VCAPApplication secret doesn't exist", func() {
+				BeforeEach(func() {
+					vcapApplicationSecretName := "doIReallyExist"
+
+					ogCFApp := cfApp.DeepCopy()
+					cfApp.Status.VCAPApplicationSecretName = vcapApplicationSecretName
+					Expect(k8sClient.Status().Patch(testCtx, cfApp, client.MergeFrom(ogCFApp))).To(Succeed())
+				})
+
+				It("errors", func() {
+					Expect(getAppEnvErr).To(MatchError(ContainSubstring("Secret")))
+				})
+			})
 		})
 
 		When("EnvSecretName is blank", func() {
@@ -1552,7 +1592,7 @@ func generateVcapServiceSecretDataByte() (map[string][]byte, error) {
 		VolumeMounts:   nil,
 	}
 
-	vcapServicesData, err := json.Marshal(env.VcapServicesPresenter{
+	vcapServicesData, err := json.Marshal(env.VCAPServices{
 		UserProvided: []env.ServiceDetails{
 			serviceDetails,
 		},

controllers/api/v1alpha1/cfapp_types.go

@@ -57,6 +57,9 @@ type CFAppStatus struct {
 
 	// VCAPServicesSecretName contains the name of the CFApp's VCAP_SERVICES Secret, which should exist in the same namespace
 	VCAPServicesSecretName string `json:"vcapServicesSecretName"`
+
+	// VCAPApplicationSecretName contains the name of the CFApp's VCAP_APPLICATION Secret, which should exist in the same namespace
+	VCAPApplicationSecretName string `json:"vcapApplicationSecretName"`
 }
 
 //+kubebuilder:object:root=true

controllers/controllers/services/cfservicebinding_controller_test.go

@@ -47,8 +47,9 @@ var _ = Describe("CFServiceBinding", func() {
 
 		Expect(k8s.Patch(context.Background(), k8sClient, desiredCFApp, func() {
 			desiredCFApp.Status = korifiv1alpha1.CFAppStatus{
-				Conditions:             nil,
-				VCAPServicesSecretName: "foo",
+				Conditions:                nil,
+				VCAPServicesSecretName:    "foo",
+				VCAPApplicationSecretName: "bar",
 			}
 			meta.SetStatusCondition(&desiredCFApp.Status.Conditions, metav1.Condition{
 				Type:   "Ready",

controllers/controllers/shared/index.go

@@ -14,6 +14,8 @@ const (
 	IndexServiceBindingAppGUID             = "serviceBindingAppGUID"
 	IndexServiceBindingServiceInstanceGUID = "serviceBindingServiceInstanceGUID"
 	IndexAppTasks                          = "appTasks"
+	IndexSpaceNamespaceName                = "spaceNamespace"
+	IndexOrgNamespaceName                  = "orgNamespace"
 )
 
 func SetupIndexWithManager(mgr manager.Manager) error {
@@ -45,6 +47,22 @@ func SetupIndexWithManager(mgr manager.Manager) error {
 		return err
 	}
 
+	err = mgr.GetFieldIndexer().IndexField(context.Background(), &korifiv1alpha1.CFSpace{}, IndexSpaceNamespaceName, func(object client.Object) []string {
+		space := object.(*korifiv1alpha1.CFSpace)
+		return []string{space.Status.GUID}
+	})
+	if err != nil {
+		return err
+	}
+
+	err = mgr.GetFieldIndexer().IndexField(context.Background(), &korifiv1alpha1.CFOrg{}, IndexOrgNamespaceName, func(object client.Object) []string {
+		org := object.(*korifiv1alpha1.CFOrg)
+		return []string{org.Status.GUID}
+	})
+	if err != nil {
+		return err
+	}
+
 	return nil
 }