/** * Builds a Styx Buffer from Netty ByteBuf. * * @param byteBuf * @return */ public static Buffer fromByteBuf(ByteBuf byteBuf) { return new Buffer(byteBuf); }
/** * Returns a Netty ByteBuf corresponding to a Styx Buffer. * * @param buffer * @return */ public static ByteBuf toByteBuf(Buffer buffer) { return buffer.delegate(); } }
@Test public void aggregatesManyBuffers() throws ExecutionException, InterruptedException { ByteStreamAggregator aggregator = new ByteStreamAggregator(Flux.just( new Buffer("x", UTF_8), new Buffer("y", UTF_8)), 100); Buffer a = aggregator.apply().get(); assertThat(a.size(), is(2)); assertThat(new String(a.content(), UTF_8), is("xy")); }
@Override public void onNext(Buffer part) { long newSize = aggregated.readableBytes() + part.size(); if (newSize > maxSize) { part.delegate().release(); aggregated.release(); subscription.cancel(); this.future.completeExceptionally( new ContentOverflowException(format("Maximum content size exceeded. Maximum size allowed is %d bytes.", maxSize))); } else { aggregated.addComponent(part.delegate()); aggregated.writerIndex(aggregated.writerIndex() + part.size()); } }
@Test public void consumesBody() { Buffer buf1 = new Buffer("foo", UTF_8); Buffer buf2 = new Buffer("bar", UTF_8); LiveHttpResponse response = response() .body(new ByteStream(Flux.just(buf1, buf2))) .build(); response.consume(); assertEquals(buf1.delegate().refCnt(), 0); assertEquals(buf2.delegate().refCnt(), 0); }
private String decodeUtf8String(Buffer buffer) { return new String(buffer.content(), UTF_8); }
@Test public void aggregatesUpToNBytes() { AtomicReference<Throwable> causeCapture = new AtomicReference<>(null); Buffer a = new Buffer("aaabbb", UTF_8); Buffer b = new Buffer("ccc", UTF_8); TestPublisher<Buffer> upstream = TestPublisher.create(); ByteStreamAggregator aggregator = new ByteStreamAggregator(upstream, 8); CompletableFuture<Buffer> future = aggregator.apply() .exceptionally(cause -> { causeCapture.set(cause); throw new RuntimeException(); }); upstream.next(a); upstream.next(b); upstream.assertCancelled(); assertTrue(future.isCompletedExceptionally()); assertThat(causeCapture.get(), instanceOf(ContentOverflowException.class)); assertThat(a.delegate().refCnt(), is(0)); assertThat(b.delegate().refCnt(), is(0)); }
private static String bytesToString(ByteStream body) { try { return new String(body.aggregate(100000).get().content(), UTF_8); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException(e); } catch (ExecutionException e) { throw new RuntimeException(e); } }
@Override public void onComplete() { future.complete(new Buffer(aggregated)); }
@Test public void emitsErrors() { AtomicReference<Throwable> causeCapture = new AtomicReference<>(null); Buffer a = new Buffer("aaabbb", UTF_8); TestPublisher<Buffer> upstream = TestPublisher.create(); ByteStreamAggregator aggregator = new ByteStreamAggregator(upstream, 8); CompletableFuture<Buffer> future = aggregator.apply() .exceptionally(cause -> { causeCapture.set(cause); throw new RuntimeException(); }); upstream.next(a); upstream.error(new RuntimeException("something broke")); upstream.assertCancelled(); assertTrue(future.isCompletedExceptionally()); assertThat(causeCapture.get(), instanceOf(RuntimeException.class)); assertThat(causeCapture.get().getMessage(), is("something broke")); assertThat(a.delegate().refCnt(), is(0)); } }
@Test public void aggregatesOneBuffer() throws ExecutionException, InterruptedException { ByteStreamAggregator aggregator = new ByteStreamAggregator(Flux.just(new Buffer("x", UTF_8)), 100); Buffer a = aggregator.apply().get(); assertThat(a.size(), is(1)); assertThat(new String(a.content(), UTF_8), is("x")); }
private static Function<Buffer, Buffer> releaseOldBuffers(Function<Buffer, Buffer> mapping) { return buffer -> { Buffer buffer2 = mapping.apply(buffer); if (buffer != buffer2) { buffer.delegate().release(); } return buffer2; }; }
private static String bytesToString(ByteStream body) throws Exception { return new String(body.aggregate(100000).get().content(), UTF_8); }
/** * Creates a new {@code ByteStream} from String. * * @param content content * @param charset Character set encoding * @return ByteStream */ public static ByteStream from(String content, Charset charset) { return new ByteStream(Flux.just(new Buffer(content, charset))); }
@Test public void toFullRequestReleasesOriginalReferenceCountedBuffers() throws ExecutionException, InterruptedException { Buffer content = new Buffer("original", UTF_8); LiveHttpRequest original = LiveHttpRequest.get("/foo") .body(new ByteStream(Flux.just(content))) .build(); HttpRequest fullRequest = Mono.from(original.aggregate(100)).block(); assertThat(content.delegate().refCnt(), is(0)); assertThat(fullRequest.bodyAs(UTF_8), is("original")); }
@Test(dataProvider = "emptyBodyResponses") public void convertsToStreamingHttpResponseWithEmptyBody(HttpResponse response) throws ExecutionException, InterruptedException { LiveHttpResponse streaming = response.stream(); byte[] result = streaming.body().aggregate(1000) .get() .content(); assertThat(result.length, is(0)); }
/** * Creates a new {@code ByteStream} from byte array. * * @param content content * @return ByteStream */ public static ByteStream from(byte[] content) { return new ByteStream(Flux.just(new Buffer(Unpooled.copiedBuffer(content)))); }
@Test public void transformerReplacesBody() { Buffer buf1 = new Buffer("chunk 1, ", UTF_8); Buffer buf2 = new Buffer("chunk 2.", UTF_8); LiveHttpResponse response1 = response(NO_CONTENT) .body(new ByteStream(Flux.just(buf1, buf2))) .build() .newBuilder() .body(body -> body.replaceWith(ByteStream.from("replacement", UTF_8))) .build(); HttpResponse response2 = Mono.from(response1.aggregate(100)).block(); assertEquals(response2.bodyAs(UTF_8), "replacement"); assertEquals(buf1.delegate().refCnt(), 0); assertEquals(buf2.delegate().refCnt(), 0); }