Examples with SubmissionPublisher java.util.concurrent.SubmissionPublisher used on opensource projects

Example 6 with SubmissionPublisher

use of java.util.concurrent.SubmissionPublisher 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")));
}

Example 7 with SubmissionPublisher

use of java.util.concurrent.SubmissionPublisher 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();
}

Example 8 with SubmissionPublisher

use of java.util.concurrent.SubmissionPublisher in project reactive-streams-jvm by reactive-streams.

the class SubmissionPublisherTckTest method createFailedPublisher.

@Override
public Publisher<Integer> createFailedPublisher() {
    final SubmissionPublisher<Integer> sp = new SubmissionPublisher<Integer>();
    sp.closeExceptionally(new IOException());
    return FlowAdapters.toPublisher(sp);
}

Example 9 with SubmissionPublisher

use of java.util.concurrent.SubmissionPublisher in project Java-9-Spring-Webflux by kkTranslation.

the class ConsumeSubmissionPublisher method publish.

public static void publish() throws InterruptedException, ExecutionException {
    CompletableFuture future = null;
    try (SubmissionPublisher publisher = new SubmissionPublisher<Long>()) {
        System.out.println("Subscriber Buffer Size: " + publisher.getMaxBufferCapacity());
        future = publisher.consume(System.out::println);
        LongStream.range(1, 10).forEach(publisher::submit);
    } finally {
        future.get();
    }
}

Example 10 with SubmissionPublisher

use of java.util.concurrent.SubmissionPublisher in project java-course by bwhyman.

the class FlowTest method test2.

// 每个订阅者均会收到相同的消息
// 属于pub/sub模式，而非P2P模式
private static void test2() throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(2);
    SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();
    MySubscriber s1 = new MySubscriber(latch);
    MySubscriber s2 = new MySubscriber(latch);
    publisher.subscribe(s1);
    publisher.subscribe(s2);
    for (int i = 0; i < 10; i++) {
        publisher.submit(i);
    }
    latch.await();
}