root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Add flushing support 

This commit add flushing support thanks to the FlushingDataBuffer
wrapper that allows to identify the elements that should trigger a
flush.
This commit is contained in:
Sebastien Deleuze 2016-06-16 12:03:41 +02:00
parent 9aa6f5caac
commit aeb35787d7
7 changed files with 263 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
spring-web-reactive/src/main/java/org/springframework/core/io/buffer/FlushingDataBuffer.java Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright 2002-2016 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.core.io.buffer;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.function.IntPredicate;
import org.springframework.util.Assert;
/**
* {@link DataBuffer} wrapper that indicates the file or the socket writing this buffer
* should be flushed.
*
* @author Sebastien Deleuze
*/
public class FlushingDataBuffer implements DataBuffer {
private final DataBuffer buffer;
public FlushingDataBuffer(DataBuffer buffer) {
Assert.notNull(buffer);
this.buffer = buffer;
}
@Override
public DataBufferFactory factory() {
return this.buffer.factory();
}
@Override
public int indexOf(IntPredicate predicate, int fromIndex) {
return this.buffer.indexOf(predicate, fromIndex);
}
@Override
public int lastIndexOf(IntPredicate predicate, int fromIndex) {
return this.buffer.lastIndexOf(predicate, fromIndex);
}
@Override
public int readableByteCount() {
return this.buffer.readableByteCount();
}
@Override
public byte read() {
return this.buffer.read();
}
@Override
public DataBuffer read(byte[] destination) {
return this.buffer.read(destination);
}
@Override
public DataBuffer read(byte[] destination, int offset, int length) {
return this.buffer.read(destination, offset, length);
}
@Override
public DataBuffer write(byte b) {
return this.buffer.write(b);
}
@Override
public DataBuffer write(byte[] source) {
return this.buffer.write(source);
}
@Override
public DataBuffer write(byte[] source, int offset, int length) {
return this.write(source, offset, length);
}
@Override
public DataBuffer write(DataBuffer... buffers) {
return this.buffer.write(buffers);
}
@Override
public DataBuffer write(ByteBuffer... buffers) {
return this.buffer.write(buffers);
}
@Override
public DataBuffer slice(int index, int length) {
return this.buffer.slice(index, length);
}
@Override
public ByteBuffer asByteBuffer() {
return this.buffer.asByteBuffer();
}
@Override
public InputStream asInputStream() {
return this.buffer.asInputStream();
}
@Override
public OutputStream asOutputStream() {
return this.buffer.asOutputStream();
}
}

3
spring-web-reactive/src/main/java/org/springframework/http/ReactiveHttpOutputMessage.java
View File

@ -23,6 +23,7 @@ import reactor.core.publisher.Mono;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.FlushingDataBuffer;
/**
* A "reactive" HTTP output message that accepts output as a {@link Publisher}.
@ -47,6 +48,8 @@ public interface ReactiveHttpOutputMessage extends HttpMessage {
* flushed before depending on the configuration, the HTTP engine and the amount of
* data sent).
*
* <p>Each {@link FlushingDataBuffer} element will trigger a flush.
*
* @param body the body content publisher
* @return a publisher that indicates completion or error.
*/

8
spring-web-reactive/src/main/java/org/springframework/http/server/reactive/ReactorServerHttpResponse.java
View File

@ -30,6 +30,7 @@ import reactor.io.netty.http.HttpChannel;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.FlushingDataBuffer;
import org.springframework.core.io.buffer.NettyDataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseCookie;
@ -66,7 +67,12 @@ public class ReactorServerHttpResponse extends AbstractServerHttpResponse
@Override
protected Mono<Void> writeWithInternal(Publisher<DataBuffer> publisher) {
return this.channel.send(Flux.from(publisher).map(this::toByteBuf));
return Flux.from(publisher)
.window()
.concatMap(w -> this.channel.send(w
.takeUntil(db -> db instanceof FlushingDataBuffer)
.map(this::toByteBuf)))
.then();
}
@Override

26
spring-web-reactive/src/main/java/org/springframework/http/server/reactive/RxNettyServerHttpResponse.java
View File

@ -17,6 +17,7 @@
package org.springframework.http.server.reactive;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.CompositeByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.cookie.Cookie;
@ -28,6 +29,7 @@ import reactor.core.publisher.Mono;
import rx.Observable;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.FlushingDataBuffer;
import org.springframework.core.io.buffer.NettyDataBuffer;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
import org.springframework.http.HttpStatus;
@ -63,20 +65,14 @@ public class RxNettyServerHttpResponse extends AbstractServerHttpResponse {
}
@Override
protected Mono<Void> writeWithInternal(Publisher<DataBuffer> publisher) {
Observable<ByteBuf> content =
RxJava1ObservableConverter.from(publisher).map(this::toByteBuf);
Observable<Void> completion = this.response.write(content);
return RxJava1ObservableConverter.from(completion).then();
protected Mono<Void> writeWithInternal(Publisher<DataBuffer> body) {
Observable<ByteBuf> content = RxJava1ObservableConverter.from(body).map(this::toByteBuf);
return RxJava1ObservableConverter.from(this.response.write(content, bb -> bb instanceof FlushingByteBuf)).then();
}
private ByteBuf toByteBuf(DataBuffer buffer) {
if (buffer instanceof NettyDataBuffer) {
return ((NettyDataBuffer) buffer).getNativeBuffer();
}
else {
return Unpooled.wrappedBuffer(buffer.asByteBuffer());
}
ByteBuf byteBuf = (buffer instanceof NettyDataBuffer ? ((NettyDataBuffer) buffer).getNativeBuffer() : Unpooled.wrappedBuffer(buffer.asByteBuffer()));
return (buffer instanceof FlushingDataBuffer ? new FlushingByteBuf(byteBuf) : byteBuf);
}
@Override
@ -104,6 +100,14 @@ public class RxNettyServerHttpResponse extends AbstractServerHttpResponse {
}
}
private class FlushingByteBuf extends CompositeByteBuf {
public FlushingByteBuf(ByteBuf byteBuf) {
super(byteBuf.alloc(), byteBuf.isDirect(), 1);
this.addComponent(true, byteBuf);
}
}
/*
While the underlying implementation of {@link ZeroCopyHttpOutputMessage} seems to
work; it does bypass {@link #applyBeforeCommit} and more importantly it doesn't change

17
spring-web-reactive/src/main/java/org/springframework/http/server/reactive/ServletHttpHandlerAdapter.java
View File

@ -39,6 +39,7 @@ import reactor.core.util.BackpressureUtils;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.core.io.buffer.FlushingDataBuffer;
import org.springframework.core.io.buffer.support.DataBufferUtils;
import org.springframework.http.HttpStatus;
import org.springframework.util.Assert;
@ -330,6 +331,9 @@ public class ServletHttpHandlerAdapter extends HttpServlet {
logger.trace("written: " + written + " total: " + total);
if (written == total) {
if (dataBuffer instanceof FlushingDataBuffer) {
flush(output);
}
releaseBuffer();
if (!completed) {
subscription.request(1);
@ -361,6 +365,17 @@ public class ServletHttpHandlerAdapter extends HttpServlet {
return bytesWritten;
}
private void flush(ServletOutputStream output) {
if (output.isReady()) {
logger.trace("Flushing");
try {
output.flush();
}
catch (IOException ignored) {
}
}
}
private void releaseBuffer() {
DataBufferUtils.release(dataBuffer);
dataBuffer = null;
@ -373,4 +388,4 @@ public class ServletHttpHandlerAdapter extends HttpServlet {
}
}
}
}

28
spring-web-reactive/src/main/java/org/springframework/http/server/reactive/UndertowHttpHandlerAdapter.java
View File

@ -35,6 +35,8 @@ import reactor.core.util.BackpressureUtils;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.FlushingDataBuffer;
import org.springframework.core.io.buffer.support.DataBufferUtils;
import org.springframework.util.Assert;
/**
@ -201,6 +203,8 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
private volatile ByteBuffer byteBuffer;
private volatile DataBuffer dataBuffer;
private volatile boolean completed = false;
private Subscription subscription;
@ -232,6 +236,7 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
logger.trace("onNext. buffer: " + dataBuffer);
this.byteBuffer = dataBuffer.asByteBuffer();
this.dataBuffer = dataBuffer;
}
@Override
@ -266,8 +271,6 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
}
}
catch (IOException ignored) {
logger.error(ignored, ignored);
}
}
@ -283,6 +286,9 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
logger.trace("written: " + written + " total: " + total);
if (written == total) {
if (dataBuffer instanceof FlushingDataBuffer) {
flush(channel);
}
releaseBuffer();
if (!completed) {
subscription.request(1);
@ -302,11 +308,6 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
}
private void releaseBuffer() {
byteBuffer = null;
}
private int writeByteBuffer(StreamSinkChannel channel) throws IOException {
int written;
int totalWritten = 0;
@ -318,8 +319,19 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
return totalWritten;
}
private void flush(StreamSinkChannel channel) throws IOException {
logger.trace("Flushing");
channel.flush();
}
private void releaseBuffer() {
DataBufferUtils.release(dataBuffer);
dataBuffer = null;
byteBuffer = null;
}
}
}
}
}

82
spring-web-reactive/src/test/java/org/springframework/http/server/reactive/FlushingIntegrationTests.java Normal file
View File

@ -0,0 +1,82 @@
/*
* Copyright 2002-2016 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.http.server.reactive;
import org.junit.Before;
import org.junit.Test;
import static org.springframework.web.client.reactive.HttpRequestBuilders.get;
import static org.springframework.web.client.reactive.WebResponseExtractors.bodyStream;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.test.TestSubscriber;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.FlushingDataBuffer;
import org.springframework.http.client.reactive.ReactorHttpClientRequestFactory;
import org.springframework.web.client.reactive.WebClient;
/**
* @author Sebastien Deleuze
*/
public class FlushingIntegrationTests extends AbstractHttpHandlerIntegrationTests {
private WebClient webClient;
@Before
public void setup() throws Exception {
super.setup();
this.webClient = new WebClient(new ReactorHttpClientRequestFactory());
}
@Test
public void testFlushing() throws Exception {
Mono<String> result = this.webClient
.perform(get("http://localhost:" + port))
.extract(bodyStream(String.class))
.take(2)
.reduce((s1, s2) -> s1 + s2);
TestSubscriber
.subscribe(result)
.await()
.assertValues("data0data1");
}
@Override
protected HttpHandler createHttpHandler() {
return new FlushingHandler();
}
private static class FlushingHandler implements HttpHandler {
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
Flux<DataBuffer> responseBody = Flux
.interval(50)
.take(2)
.concatWith(Flux.never())
.map(l -> {
byte[] data = ("data" + l).getBytes();
DataBuffer buffer = response.bufferFactory().allocateBuffer(data.length);
buffer.write(data);
return new FlushingDataBuffer(buffer);
});
return response.writeWith(responseBody);
}
}
}