use of io.helidon.common.http.DataChunk in project helidon by oracle.
the class ContextLifeCycleTest method testContextReactive.
@Test
void testContextReactive() {
Handler handler = (req, res) -> {
String cid = req.context().id();
req.content().subscribe(new Subscriber<>() {
@Override
public void onSubscribe(Subscription subscription) {
subscription.request(Long.MAX_VALUE);
}
@Override
public void onNext(DataChunk item) {
item.release();
if (!cid.equals(contextId())) {
throw new IllegalStateException("Context invalid");
}
}
@Override
public void onError(Throwable throwable) {
res.send(throwable);
}
@Override
public void onComplete() {
if (!cid.equals(contextId())) {
res.send(new IllegalStateException("Context invalid"));
} else {
res.send();
}
}
});
};
WebServer webServer = WebServer.builder(Routing.builder().post(handler)).build().start().await(10, TimeUnit.SECONDS);
ResponseStatus responseStatus = WebClient.builder().baseUri("http://localhost:" + webServer.port()).build().post().submit("some-payload").map(WebClientResponse::status).onTerminate(webServer::shutdown).await(10, TimeUnit.SECONDS);
assertThat(responseStatus.code(), is(200));
}
use of io.helidon.common.http.DataChunk in project helidon by oracle.
the class TyrusWriterPublisher method writeNext.
private void writeNext(ByteBuffer byteBuffer, CompletionHandler<ByteBuffer> handler) {
DataChunk dataChunk = DataChunk.create(true, true, byteBuffer);
if (handler != null) {
dataChunk.writeFuture(fromCompletionHandler(handler));
}
subscriber.onNext(dataChunk);
}
use of io.helidon.common.http.DataChunk in project helidon by oracle.
the class RequestContentTest method multiThreadingFilterAndReaderTest.
@SuppressWarnings("unchecked")
@Test
public void multiThreadingFilterAndReaderTest() throws Exception {
CountDownLatch subscribedLatch = new CountDownLatch(1);
SubmissionPublisher<DataChunk> publisher = new SubmissionPublisher<>(Runnable::run, 10);
ForkJoinPool.commonPool().submit(() -> {
try {
if (!subscribedLatch.await(10, TimeUnit.SECONDS)) {
fail("Subscriber didn't subscribe in timely manner!");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted!", e);
}
publisher.submit(DataChunk.create("first".getBytes()));
publisher.submit(DataChunk.create("second".getBytes()));
publisher.submit(DataChunk.create("third".getBytes()));
publisher.close();
});
Request request = requestTestStub(Multi.create(publisher));
request.content().registerFilter(originalPublisher -> subscriberDelegate -> originalPublisher.subscribe(new Subscriber<DataChunk>() {
@Override
public void onSubscribe(Subscription subscription) {
subscriberDelegate.onSubscribe(subscription);
subscribedLatch.countDown();
}
@Override
public void onNext(DataChunk item) {
// mapping the on next call only
subscriberDelegate.onNext(DataChunk.create(requestChunkAsString(item).toUpperCase().getBytes()));
}
@Override
public void onError(Throwable throwable) {
subscriberDelegate.onError(throwable);
}
@Override
public void onComplete() {
subscriberDelegate.onComplete();
}
}));
request.content().registerReader(Iterable.class, (publisher1, clazz) -> {
fail("Iterable reader should have not been used!");
throw new IllegalStateException("unreachable code");
});
request.content().registerReader(ArrayList.class, (publisher1, clazz) -> {
fail("ArrayList reader should have not been used!");
throw new IllegalStateException("unreachable code");
});
request.content().registerReader(List.class, (publisher1, clazz) -> {
CompletableFuture<List> future = new CompletableFuture<>();
List<String> list = new CopyOnWriteArrayList<>();
publisher1.subscribe(new Subscriber<DataChunk>() {
@Override
public void onSubscribe(Subscription subscription) {
subscription.request(Long.MAX_VALUE);
subscribedLatch.countDown();
}
@Override
public void onNext(DataChunk item) {
list.add(TestUtils.requestChunkAsString(item));
}
@Override
public void onError(Throwable throwable) {
fail("Received an exception: " + throwable.getMessage());
}
@Override
public void onComplete() {
future.complete(list);
}
});
return future;
});
List<String> result = (List<String>) request.content().as(List.class).toCompletableFuture().get(10, TimeUnit.SECONDS);
assertThat(result, hasItems(is("FIRST"), is("SECOND"), is("THIRD")));
}
use of io.helidon.common.http.DataChunk in project helidon by oracle.
the class NettyWebServerTest method main.
/**
* Start the test and then run:
* <pre><code>
* seq 1000 | head -c 1000 | curl -X PUT -Ssf http://localhost:8080 --data-binary @- http://localhost:8080 --data ahoj
* </code></pre>
* <p>
*
* @throws InterruptedException if the main thread is interrupted
*/
static void main(String[] args) throws InterruptedException {
WebServer webServer = WebServer.builder().port(8080).host("localhost").routing(routing((breq, bres) -> {
SubmissionPublisher<DataChunk> responsePublisher = new SubmissionPublisher<>(ForkJoinPool.commonPool(), 1024);
responsePublisher.subscribe(bres);
final AtomicReference<Subscription> subscription = new AtomicReference<>();
// Read request and immediately write to response
Multi.create(breq.bodyPublisher()).subscribe((DataChunk chunk) -> {
DataChunk responseChunk = DataChunk.create(true, chunk::release, chunk.data());
responsePublisher.submit(responseChunk);
ForkJoinPool.commonPool().submit(() -> {
try {
Thread.sleep(1);
subscription.get().request(ThreadLocalRandom.current().nextLong(1, 3));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException(e);
}
});
}, (Throwable ex) -> {
LOGGER.log(Level.WARNING, "An error occurred during the flow consumption!", ex);
}, responsePublisher::close, (Subscription s) -> {
subscription.set(s);
s.request(1);
bres.writeStatusAndHeaders(Http.Status.CREATED_201, Collections.emptyMap());
});
})).build();
webServer.start();
Thread.currentThread().join();
}
use of io.helidon.common.http.DataChunk in project helidon by oracle.
the class UnstableTempTest method cleanedTmpDuringRuntime.
@Test
void cleanedTmpDuringRuntime() throws IOException {
List<String> contents = new ArrayList<>(2);
Path jar = createJar();
URL jarUrl = new URL("jar:file:" + jar.toUri().getPath() + "!/" + FILE_NAME);
LOGGER.fine(() -> "Generated test jar url: " + jarUrl.toString());
ClassPathContentHandler classPathContentHandler = new ClassPathContentHandler(null, new ContentTypeSelector(null), "/", tmpDir, Thread.currentThread().getContextClassLoader());
// Empty headers
RequestHeaders headers = mock(RequestHeaders.class);
when(headers.isAccepted(any())).thenReturn(true);
when(headers.acceptedTypes()).thenReturn(Collections.emptyList());
ResponseHeaders responseHeaders = mock(ResponseHeaders.class);
ServerRequest request = Mockito.mock(ServerRequest.class);
Mockito.when(request.headers()).thenReturn(headers);
ServerResponse response = Mockito.mock(ServerResponse.class);
MessageBodyWriterContext ctx = MessageBodyWriterContext.create(HashParameters.create());
ctx.registerFilter(dataChunkPub -> {
String fileContent = new String(Single.create(dataChunkPub).await().bytes());
contents.add(fileContent);
return Single.just(DataChunk.create(ByteBuffer.wrap(fileContent.getBytes())));
});
Mockito.when(response.headers()).thenReturn(responseHeaders);
@SuppressWarnings("unchecked") Function<MessageBodyWriterContext, Flow.Publisher<DataChunk>> anyFunction = (Function<MessageBodyWriterContext, Flow.Publisher<DataChunk>>) Mockito.any(Function.class);
Mockito.when(response.send(anyFunction)).then(mock -> {
Function<MessageBodyWriterContext, Flow.Publisher<DataChunk>> argument = mock.getArgument(0);
return Single.create(argument.apply(ctx)).onError(throwable -> throwable.printStackTrace());
});
classPathContentHandler.sendJar(Http.Method.GET, FILE_NAME, jarUrl, request, response);
deleteTmpFiles();
classPathContentHandler.sendJar(Http.Method.GET, FILE_NAME, jarUrl, request, response);
assertThat(contents, containsInAnyOrder(FILE_CONTENT, FILE_CONTENT));
}
Aggregations