@Override
public Publisher<HandlerResult> handle(
ServerHttpRequest request, ServerHttpResponse response, Object handler) {
HttpHandler httpHandler = (HttpHandler) handler;
Publisher<Void> publisher = httpHandler.handle(request, response);
return Streams.wrap(publisher).map(aVoid -> null);
}
@Test
public void list() {
ListOrganizationsResponse page1 =
new ListOrganizationsResponse()
.withResource(
new ListOrganizationsResponseResource()
.withMetadata(new Metadata().withId("test-id-1"))
.withEntity(new ListOrganizationsResponseEntity().withName("test-name-1")))
.withTotalPages(2);
when(this.cloudFoundryClient.organizations().list(new ListOrganizationsRequest().withPage(1)))
.thenReturn(Publishers.just(page1));
ListOrganizationsResponse page2 =
new ListOrganizationsResponse()
.withResource(
new ListOrganizationsResponseResource()
.withMetadata(new Metadata().withId("test-id-2"))
.withEntity(new ListOrganizationsResponseEntity().withName("test-name-2")))
.withTotalPages(2);
when(this.cloudFoundryClient.organizations().list(new ListOrganizationsRequest().withPage(2)))
.thenReturn(Publishers.just(page2));
List<Organization> expected =
Arrays.asList(
new Organization("test-id-1", "test-name-1"),
new Organization("test-id-2", "test-name-2"));
List<Organization> actual = Streams.wrap(this.organizations.list()).toList().poll();
assertEquals(expected, actual);
}
@Test
public void decode() throws InterruptedException {
Stream<ByteBuffer> source =
Streams.just(Buffer.wrap("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}").byteBuffer());
List<Object> results =
Streams.wrap(decoder.decode(source, ResolvableType.forClass(Pojo.class), null))
.toList()
.await();
assertEquals(1, results.size());
assertEquals("foofoo", ((Pojo) results.get(0)).getFoo());
}
@Test
public void decodeMultipleChunksToArray() throws InterruptedException {
JsonObjectDecoder decoder = new JsonObjectDecoder(true);
Stream<ByteBuffer> source =
Streams.just(
Buffer.wrap("[{\"foo\": \"foofoo\", \"bar\"").byteBuffer(),
Buffer.wrap(": \"barbar\"},{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}]")
.byteBuffer());
List<String> results =
Streams.wrap(decoder.decode(source, null, null))
.map(
chunk -> {
byte[] b = new byte[chunk.remaining()];
chunk.get(b);
return new String(b, StandardCharsets.UTF_8);
})
.toList()
.await();
assertEquals(2, results.size());
assertEquals("{\"foo\": \"foofoo\", \"bar\": \"barbar\"}", results.get(0));
assertEquals("{\"foo\": \"foofoofoo\", \"bar\": \"barbarbar\"}", results.get(1));
}
private HttpServer<Buffer, Buffer> createProtocolListener() throws Exception {
final Stream<Buffer> stream =
Streams.wrap(processor)
.window(flushCount, flushTime, TimeUnit.SECONDS)
.flatMap(
new Function<Stream<Buffer>, Publisher<Buffer>>() {
@Override
public Publisher<Buffer> apply(Stream<Buffer> t) {
return t.reduce(
new Buffer(),
new BiFunction<Buffer, Buffer, Buffer>() {
@Override
public Buffer apply(Buffer prev, Buffer next) {
return prev.append(next);
}
});
}
})
.process(RingBufferWorkProcessor.<Buffer>create("gpfdist-sink-worker", 8192, false));
HttpServer<Buffer, Buffer> httpServer =
NetStreams.httpServer(
new Function<HttpServerSpec<Buffer, Buffer>, HttpServerSpec<Buffer, Buffer>>() {
@Override
public HttpServerSpec<Buffer, Buffer> apply(HttpServerSpec<Buffer, Buffer> server) {
return server.codec(new GpfdistCodec()).listen(port);
}
});
httpServer.get(
"/data",
new ReactorChannelHandler<Buffer, Buffer, HttpChannel<Buffer, Buffer>>() {
@Override
public Publisher<Void> apply(HttpChannel<Buffer, Buffer> request) {
request.responseHeaders().removeTransferEncodingChunked();
request.addResponseHeader("Content-type", "text/plain");
request.addResponseHeader("Expires", "0");
request.addResponseHeader("X-GPFDIST-VERSION", "Spring XD");
request.addResponseHeader("X-GP-PROTO", "1");
request.addResponseHeader("Cache-Control", "no-cache");
request.addResponseHeader("Connection", "close");
return request
.writeWith(
stream
.take(batchCount)
.timeout(batchTimeout, TimeUnit.SECONDS, Streams.<Buffer>empty())
.concatWith(Streams.just(Buffer.wrap(new byte[0]))))
.capacity(1l);
}
});
httpServer.start().awaitSuccess();
log.info("Server running using address=[" + httpServer.getListenAddress() + "]");
localPort = httpServer.getListenAddress().getPort();
return httpServer;
}
private HandlerMethod toHandlerMethod(Publisher<?> handlerPublisher) throws InterruptedException {
assertNotNull(handlerPublisher);
List<?> handlerList = Streams.wrap(handlerPublisher).toList().await(5, TimeUnit.SECONDS);
assertEquals(1, handlerList.size());
return (HandlerMethod) handlerList.get(0);
}
