Merge branch '4.3.x'

Author: ryanjbaxter

README.adoc

@@ -113,6 +113,13 @@ parsing or rendering it, just copying it to `${main.basedir}`
 any changes in the README it will then show up after a Maven build as
 a modified file in the correct place. Just commit it and push the change.
 
+You can generate the docs site using the following command:
+
+[indent=0]
+----
+	./mvnw -pl docs -P docs antora:antora
+----
+
 [[working-with-the-code]]
 == Working with the code
 If you don't have an IDE preference we would recommend that you use
@@ -156,20 +163,6 @@ The generated eclipse projects can be imported by selecting `import existing pro
 from the `file` menu.
 
 
-[[jce]]
-== JCE
-
-If you get an exception due to "Illegal key size" and you are using Sun’s JDK, you need to install the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files.
-See the following links for more information:
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html[Java 6 JCE]
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html[Java 7 JCE]
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html[Java 8 JCE]
-
-Extract the JCE files into the `JDK/jre/lib/security` folder for whichever version of JRE/JDK x64/x86 you use.
-
 [[contributing]]
 = Contributing
 

docs/modules/ROOT/pages/server/encryption-and-decryption.adoc

@@ -1,9 +1,6 @@
 [[encryption-and-decryption]]
 = Encryption and Decryption
 
-IMPORTANT: To use the encryption and decryption features you need the full-strength JCE installed in your JVM (it is not included by default).
-You can download the "`Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files`" from Oracle and follow the installation instructions (essentially, you need to replace the two policy files in the JRE lib/security directory with the ones that you downloaded). This is only applicable for old versions of Java. Starting from Java 9, and definitively from Java 8u161 onwards, unlimited strength cryptography is enabled by default
-
 If the remote property sources contain encrypted content (values starting with `\{cipher}`), they are decrypted before sending to clients over HTTP.
 The main advantage of this setup is that the property values need not be in plain text when they are "`at rest`" (for example, in a git repository).
 If a value cannot be decrypted, it is removed from the property source and an additional property is added with the same key but prefixed with `invalid` and a value that means "`not applicable`" (usually `<n/a>`).

docs/src/main/asciidoc/README.adoc

@@ -64,20 +64,6 @@ The refresh endpoint reports that the "sample" property changed.
 
 include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/modules/ROOT/partials/building.adoc[]
 
-[[jce]]
-== JCE
-
-If you get an exception due to "Illegal key size" and you are using Sun’s JDK, you need to install the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files.
-See the following links for more information:
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html[Java 6 JCE]
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html[Java 7 JCE]
-
-https://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html[Java 8 JCE]
-
-Extract the JCE files into the `JDK/jre/lib/security` folder for whichever version of JRE/JDK x64/x86 you use.
-
 [[contributing]]
 = Contributing
 

spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/EnvironmentController.java

@@ -49,6 +49,7 @@
 import org.springframework.web.bind.annotation.RestController;
 
 import static org.springframework.cloud.config.server.support.EnvironmentPropertySource.prepareEnvironment;
+import static org.springframework.cloud.config.server.support.EnvironmentPropertySource.resolveMapPlaceholders;
 import static org.springframework.cloud.config.server.support.EnvironmentPropertySource.resolvePlaceholders;
 import static org.springframework.cloud.config.server.support.PathUtils.isInvalidEncodedLocation;
 import static org.springframework.cloud.config.server.support.PathUtils.isInvalidProfiles;
@@ -199,10 +200,10 @@ public ResponseEntity<String> labelledJsonProperties(@PathVariable String name,
 		validateProfiles(profiles);
 		Environment environment = labelled(name, profiles, label);
 		Map<String, Object> properties = convertToMap(environment);
-		String json = this.objectMapper.writeValueAsString(properties);
 		if (resolvePlaceholders) {
-			json = resolvePlaceholders(prepareEnvironment(environment), json);
+			properties = resolveMapPlaceholders(prepareEnvironment(environment), properties);
 		}
+		String json = this.objectMapper.writeValueAsString(properties);
 		return getSuccess(json, MediaType.APPLICATION_JSON);
 	}
 
@@ -230,6 +231,9 @@ public ResponseEntity<String> labelledYaml(@PathVariable String name, @PathVaria
 		validateProfiles(profiles);
 		Environment environment = labelled(name, profiles, label);
 		Map<String, Object> result = convertToMap(environment);
+		if (resolvePlaceholders) {
+			result = resolveMapPlaceholders(prepareEnvironment(environment), result);
+		}
 		if (this.stripDocument && result.size() == 1 && result.keySet().iterator().next().equals("document")) {
 			Object value = result.get("document");
 			if (value instanceof Collection) {
@@ -240,11 +244,6 @@ public ResponseEntity<String> labelledYaml(@PathVariable String name, @PathVaria
 			}
 		}
 		String yaml = new Yaml().dumpAsMap(result);
-
-		if (resolvePlaceholders) {
-			yaml = resolvePlaceholders(prepareEnvironment(environment), yaml);
-		}
-
 		return getSuccess(yaml);
 	}
 

spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/support/EnvironmentPropertySource.java

@@ -16,21 +16,31 @@
 
 package org.springframework.cloud.config.server.support;
 
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import org.springframework.cloud.config.environment.Environment;
 import org.springframework.core.env.PropertySource;
 import org.springframework.core.env.StandardEnvironment;
+import org.springframework.util.PropertyPlaceholderHelper;
 
 /**
  * @author Spencer Gibb
  */
 public class EnvironmentPropertySource extends PropertySource<Environment> {
 
+	// Use PropertyPlaceholderHelper directly to trim whitespace from keys
+	private static final PropertyPlaceholderHelper PROPERTY_PLACEHOLDER_HELPER = new PropertyPlaceholderHelper("${",
+			"}", ":", null, true);
+
 	// "\${" (from text) or "\\${" from JSON to signal escaped placeholder
 	private static final Pattern ESCAPED_PLACEHOLDERS = Pattern.compile("[\\\\]{1,2}\\$\\{");
 
+	private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\$\\{([^}]+)}");
+
 	public EnvironmentPropertySource(Environment sources) {
 		super("cloudEnvironment", sources);
 	}
@@ -43,12 +53,63 @@ public static StandardEnvironment prepareEnvironment(Environment environment) {
 		return standardEnvironment;
 	}
 
+	/**
+	 * Resolve placeholders in flat text (used for .properties output). Handles escaped
+	 * placeholders (\${...}) by masking and restoring them.
+	 */
 	public static String resolvePlaceholders(StandardEnvironment preparedEnvironment, String text) {
 		// Mask out escaped placeholders
 		text = ESCAPED_PLACEHOLDERS.matcher(text).replaceAll("\\$_{");
 		return preparedEnvironment.resolvePlaceholders(text).replace("$_{", "${");
 	}
 
+	/**
+	 * Resolve placeholders in a nested Map structure. Walks all values recursively,
+	 * resolving any String values that contain ${...} expressions. Returns a new Map with
+	 * resolved values — the original is not modified.
+	 *
+	 * <p>
+	 * Use this before serializing to YAML or JSON so that the serializer handles
+	 * multiline values and escaping natively.
+	 */
+	public static Map<String, Object> resolveMapPlaceholders(StandardEnvironment env, Map<String, Object> map) {
+		Map<String, Object> resolved = new LinkedHashMap<>();
+		for (Map.Entry<String, Object> entry : map.entrySet()) {
+			resolved.put(entry.getKey(), resolveValue(env, entry.getValue()));
+		}
+		return resolved;
+	}
+
+	private static Object resolveValue(StandardEnvironment env, Object value) {
+		if (value instanceof String s) {
+			return resolveStringValue(env, s);
+		}
+		else if (value instanceof Map) {
+			Map<String, Object> mapValue = (Map<String, Object>) value;
+			Map<String, Object> resolved = new LinkedHashMap<>();
+			for (Map.Entry<String, Object> entry : mapValue.entrySet()) {
+				resolved.put(entry.getKey(), resolveValue(env, entry.getValue()));
+			}
+			return resolved;
+		}
+		else if (value instanceof List) {
+			List<Object> listValue = (List<Object>) value;
+			return listValue.stream().map(item -> resolveValue(env, item)).collect(Collectors.toList());
+		}
+		return value;
+	}
+
+	private static String resolveStringValue(StandardEnvironment env, String value) {
+		if (!PLACEHOLDER_PATTERN.matcher(value).find()) {
+			return value;
+		}
+		// Mask escaped placeholders
+		String masked = ESCAPED_PLACEHOLDERS.matcher(value).replaceAll("\\$_{");
+		String resolved = PROPERTY_PLACEHOLDER_HELPER.replacePlaceholders(masked,
+				(placeholder) -> env.getProperty(placeholder.strip()));
+		return resolved.replace("$_{", "${");
+	}
+
 	@Override
 	public Object getProperty(String name) {
 		for (org.springframework.cloud.config.environment.PropertySource source : getSource().getPropertySources()) {

spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/EnvironmentControllerTests.java

@@ -525,6 +525,37 @@ private void whenPlaceholdersSystemPropsWithDefault() {
 		when(this.repository.findOne("foo", "bar", null, false)).thenReturn(this.environment);
 	}
 
+	private void whenMultilinePlaceholders() {
+		Map<String, Object> map = new LinkedHashMap<String, Object>();
+		map.put("multiline", "line1\nline2\nline3\n");
+		map.put("ref", "${multiline}");
+		this.environment.add(new PropertySource("one", map));
+		when(this.repository.findOne("foo", "bar", null, false)).thenReturn(this.environment);
+	}
+
+	@Test
+	public void multilinePlaceholderResolvedInYaml() throws Exception {
+		whenMultilinePlaceholders();
+		String yaml = this.controller.yaml("foo", "bar", true).getBody();
+		Map<String, Object> map = new Yaml().load(yaml);
+		assertThat(map).containsEntry("multiline", "line1\nline2\nline3\n");
+		assertThat(map).containsEntry("ref", "line1\nline2\nline3\n");
+	}
+
+	@Test
+	public void multilinePlaceholderResolvedInJson() throws Exception {
+		whenMultilinePlaceholders();
+		String json = this.controller.jsonProperties("foo", "bar", true).getBody();
+		JSONAssert.assertEquals("{\"multiline\":\"line1\\nline2\\nline3\\n\",\"ref\":\"line1\\nline2\\nline3\\n\"}",
+				json, JSONCompareMode.STRICT);
+	}
+
+	@Test
+	public void nameStartsWithSlash() {
+		assertThatThrownBy(() -> this.controller.labelled("(_)spam", "bar", null))
+			.isInstanceOf(InvalidEnvironmentRequestException.class);
+	}
+
 	@Test
 	public void nameStartsWithSlash() {
 		assertThatThrownBy(() -> this.controller.labelled("(_)spam", "bar", null))