INT-4096: Allow Configuration of ReadOnly Headers

JIRA: https://jira.spring.io/browse/INT-4096

* Introduce `spring.integration.readOnly.headers` Integration property
* Introduce `IntegrationMessageHeaderAccessor.setReadOnlyHeaders()` and use it from the overridden `IntegrationMessageHeaderAccessor.isReadOnly()`
* Add `DefaultMessageBuilderFactory.setReadOnlyHeaders()` and delegate the value to the new `MessageBuilder.readOnlyHeaders()`
* Modify `spring.integration.properties` for the `contentType` as a `readOnly` header for testing
* Ensure that provided logic works via an appropriate modification to the `ObjectToJsonTransformerParserTests`

Increase receive timeouts in the `OutboundGatewayFunctionTests`

Fix `FileInboundTransactionTests` for slow `WatchService` issue on Linux/OS X

Also redo the `tmp` dir logic to the `TemporaryFolder` `@ClassRule`

Fix unused `import` in the `FileInboundTransactionTests`

Polishing

Conflicts:
	spring-integration-core/src/main/java/org/springframework/integration/context/IntegrationProperties.java
	spring-integration-core/src/main/resources/META-INF/spring.integration.default.properties

Some polishing and documentation

Localize `readOnly.headers` customization only in the `ObjectToJsonTransformerParserTests-context.xml`

Otherwise ti might affect many other tests and the search for the reason of failure would be enough complicated

Doc Polish

spring-integration-core/src/main/java/org/springframework/integration/IntegrationMessageHeaderAccessor.java

@@ -17,12 +17,17 @@
 package org.springframework.integration;
 
 import java.io.Closeable;
+import java.util.Arrays;
 import java.util.Date;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
 import org.springframework.messaging.support.MessageHeaderAccessor;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 /**
  *
@@ -53,10 +58,27 @@ public class IntegrationMessageHeaderAccessor extends MessageHeaderAccessor {
 
 	public static final String CLOSEABLE_RESOURCE = "closeableResource";
 
+	private Set<String> readOnlyHeaders = new HashSet<String>();
+
 	public IntegrationMessageHeaderAccessor(Message<?> message) {
 		super(message);
 	}
 
+	/**
+	 * Specify a list of headers which should be considered as read only
+	 * and prohibited from being populated in the message.
+	 * @param readOnlyHeaders the list of headers for {@code readOnly} mode.
+	 * Defaults to {@link MessageHeaders#ID} and {@link MessageHeaders#TIMESTAMP}.
+	 * @since 4.3.2
+	 * @see #isReadOnly(String)
+	 */
+	public void setReadOnlyHeaders(String... readOnlyHeaders) {
+		Assert.noNullElements(readOnlyHeaders, "'readOnlyHeaders' must not be contain null items.");
+		if (!ObjectUtils.isEmpty(readOnlyHeaders)) {
+			this.readOnlyHeaders = new HashSet<String>(Arrays.asList(readOnlyHeaders));
+		}
+	}
+
 	public Long getExpirationDate() {
 		return this.getHeader(EXPIRATION_DATE, Long.class);
 	}
@@ -130,4 +152,9 @@ public class IntegrationMessageHeaderAccessor extends MessageHeaderAccessor {
 		}
 	}
 
+	@Override
+	protected boolean isReadOnly(String headerName) {
+		return super.isReadOnly(headerName) || this.readOnlyHeaders.contains(headerName);
+	}
+
 }

spring-integration-core/src/main/java/org/springframework/integration/config/IntegrationRegistrar.java

@@ -417,7 +417,9 @@ public class IntegrationRegistrar implements ImportBeanDefinitionRegistrar, Bean
 		}
 		if (!alreadyRegistered) {
 			BeanDefinitionBuilder mbfBuilder = BeanDefinitionBuilder
-					.genericBeanDefinition(DefaultMessageBuilderFactory.class);
+					.genericBeanDefinition(DefaultMessageBuilderFactory.class)
+					.addPropertyValue("readOnlyHeaders",
+							IntegrationProperties.getExpressionFor(IntegrationProperties.READ_ONLY_HEADERS));
 			registry.registerBeanDefinition(
 					IntegrationUtils.INTEGRATION_MESSAGE_BUILDER_FACTORY_BEAN_NAME,
 					mbfBuilder.getBeanDefinition());

spring-integration-core/src/main/java/org/springframework/integration/context/IntegrationProperties.java

@@ -66,6 +66,12 @@ public final class IntegrationProperties {
 	 */
 	public static final String THROW_EXCEPTION_ON_LATE_REPLY = INTEGRATION_PROPERTIES_PREFIX + "messagingTemplate.throwExceptionOnLateReply";
 
+	/**
+	 * Specifies the value of {@link org.springframework.integration.support.DefaultMessageBuilderFactory#readOnlyHeaders}.
+	 */
+	public static final String READ_ONLY_HEADERS = INTEGRATION_PROPERTIES_PREFIX + "readOnly.headers";
+
+
 	private static Properties defaults;
 
 	static {

spring-integration-core/src/main/java/org/springframework/integration/support/DefaultMessageBuilderFactory.java

@@ -17,22 +17,39 @@
 package org.springframework.integration.support;
 
 import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
 
 /**
  * @author Gary Russell
+ * @author Artem Bilan
  * @since 4.0
  *
  */
 public class DefaultMessageBuilderFactory implements MessageBuilderFactory {
 
+	private String[] readOnlyHeaders;
+
+	/**
+	 * Specify a list of headers which should be considered as a read only
+	 * and prohibited from the population to the message.
+	 * @param readOnlyHeaders the list of headers for {@code readOnly} mode.
+	 * Defaults to {@link MessageHeaders#ID} and {@link MessageHeaders#TIMESTAMP}.
+	 * @since 4.3.2
+	 */
+	public void setReadOnlyHeaders(String... readOnlyHeaders) {
+		this.readOnlyHeaders = readOnlyHeaders;
+	}
+
 	@Override
 	public <T> MessageBuilder<T> fromMessage(Message<T> message) {
-		return MessageBuilder.fromMessage(message);
+		return MessageBuilder.fromMessage(message)
+				.readOnlyHeaders(this.readOnlyHeaders);
 	}
 
 	@Override
 	public <T> MessageBuilder<T> withPayload(T payload) {
-		return MessageBuilder.withPayload(payload);
+		return MessageBuilder.withPayload(payload)
+				.readOnlyHeaders(this.readOnlyHeaders);
 	}
 
 }

spring-integration-core/src/main/java/org/springframework/integration/support/MessageBuilder.java

@@ -274,6 +274,21 @@ public final class MessageBuilder<T> extends AbstractIntegrationMessageBuilder<T
 		return this;
 	}
 
+	/**
+	 * Specify a list of headers which should be considered as read only
+	 * and prohibited from being populated in the message.
+	 * @param readOnlyHeaders the list of headers for {@code readOnly} mode.
+	 * Defaults to {@link MessageHeaders#ID} and {@link MessageHeaders#TIMESTAMP}.
+	 * @since 4.3.2
+	 * @see IntegrationMessageHeaderAccessor#isReadOnly(String)
+	 */
+	public MessageBuilder<T> readOnlyHeaders(String... readOnlyHeaders) {
+		this.headerAccessor.setReadOnlyHeaders(readOnlyHeaders);
+		return this;
+	}
+
+
+
 	@Override
 	@SuppressWarnings("unchecked")
 	public Message<T> build() {

spring-integration-core/src/main/resources/META-INF/spring.integration.default.properties

@@ -3,3 +3,5 @@ spring.integration.channels.maxUnicastSubscribers=0x7fffffff
 spring.integration.channels.maxBroadcastSubscribers=0x7fffffff
 spring.integration.taskScheduler.poolSize=10
 spring.integration.messagingTemplate.throwExceptionOnLateReply=false
+# Defaults to MessageHeaders.ID and MessageHeaders.TIMESTAMP
+spring.integration.readOnly.headers=

spring-integration-core/src/test/java/org/springframework/integration/json/ObjectToJsonTransformerParserTests-context.xml

@@ -1,17 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xmlns:beans="http://www.springframework.org/schema/beans"
-	xsi:schemaLocation="http://www.springframework.org/schema/beans
-		http://www.springframework.org/schema/beans/spring-beans.xsd
-		http://www.springframework.org/schema/integration
-		http://www.springframework.org/schema/integration/spring-integration.xsd">
+			 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+			 xmlns:beans="http://www.springframework.org/schema/beans"
+			 xmlns:util="http://www.springframework.org/schema/util"
+			 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
+		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
+
+	<util:properties id="integrationGlobalProperties">
+		<beans:prop key="spring.integration.readOnly.headers">contentType,foo</beans:prop>
+	</util:properties>
 
 	<object-to-json-transformer id="defaultTransformer" input-channel="defaultObjectMapperInput"/>
 
 	<object-to-json-transformer id="emptyContentTypeTransformer" input-channel="customObjectMapperInput" content-type=""/>
 
-	<object-to-json-transformer id="overridenContentTypeTransformer" input-channel="customObjectMapperInput" content-type="text/xml"/>
+	<object-to-json-transformer id="overriddenContentTypeTransformer" input-channel="customObjectMapperInput" content-type="text/xml"/>
 
 	<object-to-json-transformer id="customJsonObjectMapperTransformer" input-channel="customJsonObjectMapperInput"
 								object-mapper="customJsonObjectMapper"/>

spring-integration-core/src/test/java/org/springframework/integration/json/ObjectToJsonTransformerParserTests.java

@@ -37,6 +37,7 @@ import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
 import org.springframework.integration.channel.QueueChannel;
 import org.springframework.integration.mapping.support.JsonHeaders;
+import org.springframework.integration.support.DefaultMessageBuilderFactory;
 import org.springframework.integration.support.MessageBuilder;
 import org.springframework.integration.support.json.Jackson2JsonObjectMapper;
 import org.springframework.integration.support.json.JsonObjectMapperAdapter;
@@ -61,45 +62,57 @@ import com.fasterxml.jackson.databind.JsonNode;
 public class ObjectToJsonTransformerParserTests {
 
 	@Autowired
-	private volatile ApplicationContext context;
+	private ApplicationContext context;
 
 	@Autowired
-	private volatile MessageChannel defaultObjectMapperInput;
+	private MessageChannel defaultObjectMapperInput;
 
 	@Autowired
-	private volatile MessageChannel customJsonObjectMapperInput;
+	private MessageChannel customJsonObjectMapperInput;
 
 	@Autowired
-	private volatile MessageChannel jsonNodeInput;
+	private MessageChannel jsonNodeInput;
 
 	@Autowired
-	private volatile MessageChannel boonJsonNodeInput;
+	private MessageChannel boonJsonNodeInput;
+
+	@Autowired
+	private DefaultMessageBuilderFactory defaultMessageBuilderFactory;
 
 	@Test
 	public void testContentType() {
 		ObjectToJsonTransformer transformer =
-				TestUtils.getPropertyValue(context.getBean("defaultTransformer"), "handler.transformer", ObjectToJsonTransformer.class);
+				TestUtils.getPropertyValue(context.getBean("defaultTransformer"), "handler.transformer",
+						ObjectToJsonTransformer.class);
 		assertEquals("application/json", TestUtils.getPropertyValue(transformer, "contentType"));
 
-		assertEquals(Jackson2JsonObjectMapper.class, TestUtils.getPropertyValue(transformer, "jsonObjectMapper").getClass());
+		assertEquals(Jackson2JsonObjectMapper.class,
+				TestUtils.getPropertyValue(transformer, "jsonObjectMapper").getClass());
 
 		Message<?> transformed = transformer.transform(MessageBuilder.withPayload("foo").build());
-		assertTrue(transformed.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE));
-		assertEquals("application/json", transformed.getHeaders().get(MessageHeaders.CONTENT_TYPE));
+
+		// spring.integration.readOnly.headers=contentType, so no 'contentType'
+		assertFalse(transformed.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE));
+
+		// Reset readOnlyHeaders to defaults. Therefore the 'contentType' should be presented in subsequent tests
+		this.defaultMessageBuilderFactory.setReadOnlyHeaders();
 
 		transformer =
-				TestUtils.getPropertyValue(context.getBean("emptyContentTypeTransformer"), "handler.transformer", ObjectToJsonTransformer.class);
+				TestUtils.getPropertyValue(context.getBean("emptyContentTypeTransformer"), "handler.transformer",
+						ObjectToJsonTransformer.class);
 		assertEquals("", TestUtils.getPropertyValue(transformer, "contentType"));
 
 		transformed = transformer.transform(MessageBuilder.withPayload("foo").build());
 		assertFalse(transformed.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE));
 
-		transformed = transformer.transform(MessageBuilder.withPayload("foo").setHeader(MessageHeaders.CONTENT_TYPE, "foo").build());
+		transformed = transformer.transform(MessageBuilder.withPayload("foo").setHeader(MessageHeaders.CONTENT_TYPE,
+				"foo").build());
 		assertNotNull(transformed.getHeaders().get(MessageHeaders.CONTENT_TYPE));
 		assertEquals("foo", transformed.getHeaders().get(MessageHeaders.CONTENT_TYPE));
 
 		transformer =
-				TestUtils.getPropertyValue(context.getBean("overridenContentTypeTransformer"), "handler.transformer", ObjectToJsonTransformer.class);
+				TestUtils.getPropertyValue(context.getBean("overriddenContentTypeTransformer"), "handler.transformer",
+						ObjectToJsonTransformer.class);
 		assertEquals("text/xml", TestUtils.getPropertyValue(transformer, "contentType"));
 	}
 
@@ -165,7 +178,8 @@ public class ObjectToJsonTransformerParserTests {
 		assertThat(payload, Matchers.instanceOf(JsonNode.class));
 		StandardEvaluationContext evaluationContext = new StandardEvaluationContext();
 		evaluationContext.addPropertyAccessor(new JsonPropertyAccessor());
-		Expression expression = new SpelExpressionParser().parseExpression("firstName.toString() == 'John' and age.toString() == '42'");
+		Expression expression = new SpelExpressionParser()
+				.parseExpression("firstName.toString() == 'John' and age.toString() == '42'");
 
 		assertTrue(expression.getValue(evaluationContext, payload, Boolean.class));
 	}
@@ -195,6 +209,7 @@ public class ObjectToJsonTransformerParserTests {
 		public String toJson(Object value) throws Exception {
 			return "{" + value.toString() + "}";
 		}
+
 	}
 
 }