Add support for server-side events and tests

User can POST to web endpoint in SSE style, i.e:

HTTP/1.1
Content-Type: text/event-stream

data:foo

data:bar

Will be converted to a Flux with values foo and bar

spring-cloud-function-deployer/pom.xml

@@ -30,6 +30,11 @@
 			<artifactId>spring-cloud-function-web</artifactId>
 			<version>${project.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.cloud</groupId>
+			<artifactId>spring-cloud-function-stream</artifactId>
+			<version>${project.version}</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-configuration-processor</artifactId>

spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/ApplicationRunner.java

@@ -45,6 +45,8 @@ import org.springframework.boot.loader.thin.ArchiveUtils;
 import org.springframework.cloud.deployer.thin.ContextRunner;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.core.SpringVersion;
+import org.springframework.messaging.Message;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
@@ -60,6 +62,8 @@ public class ApplicationRunner implements CommandLineRunner {
 
 	private static final String DEFAULT_REACTOR_VERSION = "3.0.4.RELEASE";
 
+	private static final String DEFAULT_SPRING_VERSION = SpringVersion.getVersion();
+
 	private static Log logger = LogFactory.getLog(ApplicationRunner.class);
 
 	public static void main(String[] args) {
@@ -125,14 +129,18 @@ public class ApplicationRunner implements CommandLineRunner {
 		for (URL url : urls) {
 			child.add(url);
 		}
-		String reactor = getReactorCoordinates();
 		DependencyResolutionContext context = new DependencyResolutionContext();
 		AetherEngine engine = AetherEngine.create(
 				RepositoryConfigurationFactory.createDefaultRepositoryConfiguration(),
 				context);
+		String reactor = getReactorCoordinates();
+		// spring-core is OK, spring-context is not, spring-messaging depends on
+		// spring-context (so it is not OK)
+		String spring = getSpringCoordinates();
 		try {
-			List<File> resolved = engine.resolve(Arrays
-					.asList(new Dependency(new DefaultArtifact(reactor), "runtime")));
+			List<File> resolved = engine.resolve(
+					Arrays.asList(new Dependency(new DefaultArtifact(reactor), "runtime"),
+							new Dependency(new DefaultArtifact(spring), "runtime")));
 			for (File archive : resolved) {
 				try {
 					URL url = archive.toURI().toURL();
@@ -155,6 +163,13 @@ public class ApplicationRunner implements CommandLineRunner {
 		return new URLClassLoader(child.toArray(new URL[0]), base);
 	}
 
+	private String getSpringCoordinates() {
+		Package pkg = Message.class.getPackage();
+		String version = null;
+		version = (pkg != null ? pkg.getImplementationVersion() : DEFAULT_SPRING_VERSION);
+		return "org.springframework:spring-core:" + version;
+	}
+
 	private String getReactorCoordinates() {
 		Package pkg = Flux.class.getPackage();
 		String version = null;

spring-cloud-function-deployer/src/test/java/org/springframework/cloud/function/deployer/FunctionExtractingFunctionCatalogIntegrationTests.java

@@ -38,7 +38,8 @@ public class FunctionExtractingFunctionCatalogIntegrationTests {
 	public static void open() {
 		port = SocketUtils.findAvailableTcpPort();
 		// System.setProperty("debug", "true");
-		context = new ApplicationRunner().start("--server.port=" + port);
+		context = new ApplicationRunner().start("--server.port=" + port,
+				"--spring.cloud.stream.enabled=false");
 	}
 
 	@AfterClass

spring-cloud-function-stream/src/main/java/org/springframework/cloud/function/stream/StreamConfiguration.java

@@ -38,6 +38,7 @@ import reactor.core.publisher.Flux;
 @EnableBinding(Processor.class)
 @EnableConfigurationProperties(FunctionConfigurationProperties.class)
 @ConditionalOnClass({ Binder.class, AbstractFunctionInvoker.class })
+@ConditionalOnProperty(name = "spring.cloud.stream.enabled", havingValue = "true", matchIfMissing = true)
 public class StreamConfiguration {
 
 	@Autowired

spring-cloud-function-web/pom.xml

@@ -28,6 +28,16 @@
 			<artifactId>spring-cloud-function-core</artifactId>
 			<version>${project.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.cloud</groupId>
+			<artifactId>spring-cloud-function-context</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+		</dependency>
 	</dependencies>
 
 	<dependencyManagement>

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/FunctionController.java

@@ -18,10 +18,10 @@ package org.springframework.cloud.function.web;
 import java.util.function.Function;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.context.embedded.ReactiveServerProperties;
 import org.springframework.cloud.function.registry.FunctionCatalog;
-import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -38,6 +38,9 @@ import reactor.core.publisher.Flux;
 @ConditionalOnClass({ RestController.class, ReactiveServerProperties.class })
 public class FunctionController {
 
+	@Value("${debug:${DEBUG:false}}")
+	private boolean debug = false;
+
 	private final FunctionCatalog functions;
 
 	@Autowired
@@ -45,7 +48,7 @@ public class FunctionController {
 		this.functions = catalog;
 	}
 
-	@PostMapping(path = "/{name}", consumes = MediaType.TEXT_PLAIN_VALUE)
+	@PostMapping(path = "/{name}")
 	public Flux<String> function(@PathVariable String name,
 			@RequestBody Flux<String> body) {
 		Function<Object, Object> function;
@@ -57,14 +60,14 @@ public class FunctionController {
 		}
 		@SuppressWarnings("unchecked")
 		Flux<String> result = (Flux<String>) function.apply(body);
-		return result;
+		return debug ? result.log() : result;
 	}
 
-	@GetMapping("/{name}")
+	@GetMapping(path = "/{name}")
 	public Flux<String> supplier(@PathVariable String name) {
 		@SuppressWarnings("unchecked")
 		Flux<String> result = (Flux<String>) functions.lookupSupplier(name).get();
-		return result;
+		return debug ? result.log() : result;
 	}
 
 }

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/RestApplication.java

@@ -16,16 +16,97 @@
 
 package org.springframework.cloud.function.web;
 
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.IntPredicate;
+
+import org.reactivestreams.Publisher;
+
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.core.ResolvableType;
+import org.springframework.core.codec.StringDecoder;
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferUtils;
+import org.springframework.http.MediaType;
+import org.springframework.http.codec.DecoderHttpMessageReader;
+import org.springframework.http.codec.HttpMessageReader;
+import org.springframework.util.MimeType;
+import org.springframework.web.reactive.config.WebReactiveConfigurer;
+
+import reactor.core.publisher.Flux;
 
 /**
  * @author Mark Fisher
  */
 @SpringBootApplication
-public class RestApplication {
+public class RestApplication implements WebReactiveConfigurer {
+
+	@Override
+	public void extendMessageReaders(List<HttpMessageReader<?>> readers) {
+		readers.add(0, new DecoderHttpMessageReader<>(new SseDecoder()));
+	}
 
 	public static void main(String[] args) {
 		SpringApplication.run(RestApplication.class, args);
 	}
 }
+
+class SseDecoder extends StringDecoder {
+
+	private static final IntPredicate NEWLINE_DELIMITER = b -> b == '\n' || b == '\r';
+
+	@Override
+	public boolean canDecode(ResolvableType elementType, MimeType mimeType) {
+		return super.canDecode(elementType, mimeType)
+				&& MediaType.TEXT_EVENT_STREAM.isCompatibleWith(mimeType);
+	}
+
+	@Override
+	public Flux<String> decode(Publisher<DataBuffer> inputStream,
+			ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) {
+
+		Flux<DataBuffer> inputFlux = Flux.from(inputStream);
+		inputFlux = Flux.from(inputStream).flatMap(SseDecoder::splitOnNewline);
+		return inputFlux.map(buffer -> decodeDataBuffer(buffer, mimeType));
+	}
+
+	private static Flux<DataBuffer> splitOnNewline(DataBuffer dataBuffer) {
+		List<DataBuffer> results = new ArrayList<>();
+		int startIdx = 0;
+		int endIdx;
+		final int limit = dataBuffer.readableByteCount();
+		do {
+			endIdx = dataBuffer.indexOf(NEWLINE_DELIMITER, startIdx);
+			endIdx = dataBuffer.indexOf(NEWLINE_DELIMITER, endIdx + 1);
+			int length = (endIdx != -1 ? endIdx - startIdx + 1 : limit - startIdx) - 7;
+			if (length > 0) {
+				DataBuffer token = dataBuffer.slice(startIdx + 5, length);
+				results.add(DataBufferUtils.retain(token));
+			}
+			startIdx = endIdx + 1;
+		}
+		while (startIdx < limit && endIdx != -1);
+		DataBufferUtils.release(dataBuffer);
+		return Flux.fromIterable(results);
+	}
+
+	private String decodeDataBuffer(DataBuffer dataBuffer, MimeType mimeType) {
+		Charset charset = getCharset(mimeType);
+		CharBuffer charBuffer = charset.decode(dataBuffer.asByteBuffer());
+		DataBufferUtils.release(dataBuffer);
+		return charBuffer.toString();
+	}
+
+	private Charset getCharset(MimeType mimeType) {
+		if (mimeType != null && mimeType.getCharset() != null) {
+			return mimeType.getCharset();
+		}
+		else {
+			return DEFAULT_CHARSET;
+		}
+	}
+}

spring-cloud-function-web/src/test/java/org/springframework/cloud/function/web/RestApplicationTests.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2016-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.cloud.function.web;
+
+import java.net.URI;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.embedded.LocalServerPort;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.context.annotation.Bean;
+import org.springframework.http.MediaType;
+import org.springframework.http.RequestEntity;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.StringUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import reactor.core.publisher.Flux;
+
+/**
+ * @author Dave Syer
+ *
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+public class RestApplicationTests {
+
+	@LocalServerPort
+	private int port;
+	private TestRestTemplate rest = new TestRestTemplate();
+
+	@Test
+	public void wordsSSE() throws Exception {
+		assertThat(
+				rest.exchange(
+						RequestEntity.get(new URI("http://localhost:" + port + "/words"))
+								.accept(MediaType.TEXT_EVENT_STREAM).build(),
+						String.class).getBody()).isEqualTo(sse("foo", "bar"));
+	}
+
+	@Test
+	public void words() throws Exception {
+		assertThat(rest.exchange(
+				RequestEntity.get(new URI("http://localhost:" + port + "/words")).build(),
+				String.class).getBody()).isEqualTo("foobar");
+	}
+
+	@Test
+	public void uppercase() {
+		assertThat(rest.postForObject("http://localhost:" + port + "/uppercase",
+				"foo\nbar", String.class)).isEqualTo("[FOO][BAR]");
+	}
+
+	@Test
+	public void uppercaseSSE() throws Exception {
+		assertThat(rest.exchange(
+				RequestEntity.post(new URI("http://localhost:" + port + "/uppercase"))
+						.accept(MediaType.TEXT_EVENT_STREAM)
+						.contentType(MediaType.TEXT_EVENT_STREAM).body(sse("foo", "bar")),
+				String.class).getBody()).isEqualTo(sse("[FOO]", "[BAR]"));
+	}
+
+	private String sse(String... values) {
+		return "data:" + StringUtils.arrayToDelimitedString(values, "\n\ndata:") + "\n\n";
+	}
+
+	@SpringBootApplication
+	public static class TestConfiguration {
+
+		@Bean
+		public Function<Flux<String>, Flux<String>> uppercase() {
+			return flux -> flux.map(value -> "[" + value.trim().toUpperCase() + "]");
+		}
+
+		@Bean
+		public Supplier<Flux<String>> words() {
+			return () -> Flux.fromArray(new String[] { "foo", "bar" });
+		}
+
+	}
+
+}