From 6d3ea5e8b2d57cc679381e843daf43c06b80fed7 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Tue, 29 Oct 2019 14:38:45 +0100 Subject: [PATCH 01/66] Kafka connector with partial MicroProfile Reactive Messaging Specification Signed-off-by: Daniel Kec --- messaging/kafka/pom.xml | 119 +++++++++ .../kafka/InvalidKafkaConsumerState.java | 32 +++ .../kafka/KafkaConfigProperties.java | 103 ++++++++ .../kafka/PartitionsAssignedLatch.java | 43 ++++ .../messaging/kafka/SimpleKafkaConsumer.java | 236 ++++++++++++++++++ .../messaging/kafka/SimpleKafkaProducer.java | 144 +++++++++++ .../connector/KafkaConnectorFactory.java | 62 +++++ .../kafka/connector/KafkaMessage.java | 58 +++++ .../kafka/connector/SimplePublisher.java | 42 ++++ .../connector/SimplePublisherBuilder.java | 220 ++++++++++++++++ .../messaging/kafka/SimpleKafkaTest.java | 160 ++++++++++++ .../src/test/resources/logging.properties | 31 +++ microprofile/messaging/pom.xml | 116 +++++++++ .../IncomingSubscriber.java | 109 ++++++++ .../MessagingCdiExtension.java | 74 ++++++ .../javax.enterprise.inject.spi.Extension | 17 ++ .../KafkaConsumingTestBean.java | 46 ++++ .../MessagingCdiExtensionTest.java | 180 +++++++++++++ .../src/test/resources/application.yaml | 28 +++ .../src/test/resources/logging.properties | 31 +++ 20 files changed, 1851 insertions(+) create mode 100644 messaging/kafka/pom.xml create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java create mode 100644 messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java create mode 100644 messaging/kafka/src/test/resources/logging.properties create mode 100644 microprofile/messaging/pom.xml create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java create mode 100644 microprofile/messaging/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension create mode 100644 microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java create mode 100644 microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java create mode 100644 microprofile/messaging/src/test/resources/application.yaml create mode 100644 microprofile/messaging/src/test/resources/logging.properties diff --git a/messaging/kafka/pom.xml b/messaging/kafka/pom.xml new file mode 100644 index 00000000000..ff7a2f6799d --- /dev/null +++ b/messaging/kafka/pom.xml @@ -0,0 +1,119 @@ + + + + + + 4.0.0 + + io.helidon.messaging.connectors + kafka-connector + 1.3.2-SNAPSHOT + jar + Helidon Kafka Connector + + + 8 + 8 + UTF-8 + + + + + javax.enterprise + cdi-api + 2.0 + provided + + + org.eclipse.microprofile.reactive.messaging + microprofile-reactive-messaging-api + 1.0 + + + org.eclipse.microprofile.reactive-streams-operators + microprofile-reactive-streams-operators-core + 1.0.1 + + + io.helidon.config + helidon-config-yaml + 1.2.2-SNAPSHOT + + + io.helidon.microprofile.config + helidon-microprofile-config + 1.3.2-SNAPSHOT + + + org.apache.kafka + kafka_2.11 + 2.3.0 + + + org.apache.kafka + kafka-clients + 2.3.0 + + + org.junit.jupiter + junit-jupiter-api + 5.6.0-M1 + test + + + org.junit.jupiter + junit-jupiter + 5.6.0-M1 + test + + + com.salesforce.kafka.test + kafka-junit5 + 3.1.1 + test + + + + org.slf4j + slf4j-jdk14 + 1.7.28 + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0-M3 + + + + java.util.logging.config.file + src/test/resources/logging.properties + + + + + + + + diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java new file mode 100644 index 00000000000..d256e3b9dce --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka; + +/** + * Runtime exception for Consumer validation errors + */ +public class InvalidKafkaConsumerState extends RuntimeException { + + /** + * Creates {@link io.helidon.messaging.kafka.InvalidKafkaConsumerState} runtime exception + * + * @param message the message + */ + public InvalidKafkaConsumerState(String message) { + super(message); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java new file mode 100644 index 00000000000..ace6ef9cdc6 --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka; + +import io.helidon.config.Config; + +import java.util.Arrays; +import java.util.List; +import java.util.Properties; +import java.util.stream.Collectors; + +/** + * Prepare Kafka properties from Helidon {@link io.helidon.config.Config Config}. + * Configuration format as specified in the MicroProfile Reactive Messaging + * Specification https://github.com/eclipse/microprofile-reactive-messaging + * + *

+ * See example with YAML configuration: + * 

{@code
+ * mp.messaging:
+ *   incoming:
+ *     test-channel:
+ *       bootstrap.servers: localhost:9092
+ *       topic: graph-done
+ *       key.deserializer: org.apache.kafka.common.serialization.LongDeserializer
+ *       value.deserializer: org.apache.kafka.common.serialization.StringDeserializer
+ *
+ *   outcoming:
+ *     test-channel:
+ *       bootstrap.servers: localhost:9092
+ *       topic: graph-done
+ *       key.serializer: org.apache.kafka.common.serialization.LongSerializer
+ *       value.serializer: org.apache.kafka.common.serialization.StringSerializer
+ *
+ * }
+ *

+ * + * @see io.helidon.config.Config + */ +public class KafkaConfigProperties extends Properties { + + /** + * Topic or topics delimited by commas + */ + static final String TOPIC_NAME = "topic"; + + /** + * Consumer group id + */ + static final String GROUP_ID = "group.id"; + + /** + * Prepare Kafka properties from Helidon {@link io.helidon.config.Config Config}, + * underscores in keys are translated to dots. + * + * @param config parent config of kafka key + */ + KafkaConfigProperties(Config config) { + config.asNodeList().get().forEach(this::addProperty); + } + + /** + * Split comma separated topic names + * + * @return list of topic names + */ + public List getTopicNameList() { + return Arrays.stream(getProperty(TOPIC_NAME) + .split(",")) + .map(String::trim) + .collect(Collectors.toList()); + } + + private void addProperty(Config c) { + String key = c.traverse().map(m -> m.key().parent().name() + "." + m.key().name()) + .collect(Collectors.joining(".")); + if (key.isEmpty()) { + key = c.key().name(); + } + String value; + if (c.hasValue()) { + value = c.asString().get(); + } else { + value = c.traverse(v -> v.type() == Config.Type.VALUE).findFirst() + .get().asString().get(); + } + this.setProperty(key, value); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java new file mode 100644 index 00000000000..268b6a26f27 --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka; + +import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; +import org.apache.kafka.common.TopicPartition; + +import java.util.Collection; +import java.util.concurrent.CountDownLatch; + +/** + * Waiting latch for partition assigment, after that is consumer ready to receive + */ +public class PartitionsAssignedLatch extends CountDownLatch implements ConsumerRebalanceListener { + + public PartitionsAssignedLatch() { + super(1); + } + + @Override + public void onPartitionsRevoked(Collection partitions) { + // Do nothing + } + + @Override + public void onPartitionsAssigned(Collection partitions) { + this.countDown(); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java new file mode 100644 index 00000000000..1dab68af266 --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java @@ -0,0 +1,236 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka; + +import io.helidon.config.Config; +import io.helidon.messaging.kafka.connector.KafkaMessage; +import io.helidon.messaging.kafka.connector.SimplePublisherBuilder; +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.apache.kafka.clients.consumer.ConsumerRecords; +import org.apache.kafka.clients.consumer.KafkaConsumer; +import org.apache.kafka.common.errors.WakeupException; + +import java.io.Closeable; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; +import java.util.logging.Logger; + +/** + * Simple Kafka consumer covering basic use-cases. + * Configurable by Helidon {@link io.helidon.config.Config Config}, + * For more info about configuration see {@link KafkaConfigProperties} + *

+ * Usage: + * 

{@code
+ *   try (SimpleKafkaConsumer c = new SimpleKafkaConsumer<>("test-channel", Config.create())) {
+ *         c.consumeAsync(r -> System.out.println(r.value()));
+ *   }
+ * }
+ * + * @param Key type + * @param Value type + * @see KafkaConfigProperties + * @see io.helidon.config.Config + */ +public class SimpleKafkaConsumer implements Closeable { + + private static final Logger LOGGER = Logger.getLogger(SimpleKafkaConsumer.class.getName()); + private final KafkaConfigProperties properties; + + private AtomicBoolean closed = new AtomicBoolean(false); + private PartitionsAssignedLatch partitionsAssignedLatch = new PartitionsAssignedLatch(); + private String consumerId; + private ExecutorService executorService; + private ExecutorService externalExecutorService; + private List topicNameList; + private KafkaConsumer consumer; + + /** + * Kafka consumer created from {@link io.helidon.config.Config config} + * see configuration {@link KafkaConfigProperties example}. + * + * @param channelName key in configuration + * @param config Helidon {@link io.helidon.config.Config config} + * @see KafkaConfigProperties + * @see io.helidon.config.Config + */ + public SimpleKafkaConsumer(String channelName, Config config) { + this(channelName, config, null); + } + + /** + * Kafka consumer created from {@link io.helidon.config.Config config} + * see configuration {@link KafkaConfigProperties example}. + * + * @param channelName key in configuration + * @param config Helidon {@link io.helidon.config.Config config} + * @param consumerGroupId Custom group.id, can be null, overrides group.id from configuration + * @see KafkaConfigProperties + * @see io.helidon.config.Config + */ + public SimpleKafkaConsumer(String channelName, Config config, String consumerGroupId) { + properties = new KafkaConfigProperties(config.get("mp.messaging.incoming").get(channelName)); + properties.setProperty(KafkaConfigProperties.GROUP_ID, getOrGenerateGroupId(consumerGroupId)); + this.topicNameList = properties.getTopicNameList(); + this.consumerId = channelName; + consumer = new KafkaConsumer<>(properties); + } + + public SimpleKafkaConsumer(Config config) { + properties = new KafkaConfigProperties(config); + properties.setProperty(KafkaConfigProperties.GROUP_ID, getOrGenerateGroupId(null)); + this.topicNameList = properties.getTopicNameList(); + this.consumerId = null; + consumer = new KafkaConsumer<>(properties); + } + + /** + * Execute supplied consumer for each received record + * + * @param function to be executed for each received record + */ + public Future consumeAsync(Consumer> function) { + return this.consumeAsync(Executors.newWorkStealingPool(), null, function); + } + + /** + * Execute supplied consumer by provided executor service for each received record + * + * @param executorService Custom executor service used for spinning up polling thread and record consuming threads + * @param customTopics Can be null, list of topics appended to the list from configuration + * @param function Consumer method executed in new thread for each received record + * @return The Future's get method will return null when consumer is closed + */ + public Future consumeAsync(ExecutorService executorService, List customTopics, + Consumer> function) { + LOGGER.info(String.format("Initiating kafka consumer %s listening to topics: %s with groupId: %s", + consumerId, topicNameList, properties.getProperty(KafkaConfigProperties.GROUP_ID))); + + List mergedTopics = new ArrayList<>(); + mergedTopics.addAll(properties.getTopicNameList()); + mergedTopics.addAll(Optional.ofNullable(customTopics).orElse(Collections.emptyList())); + + if (mergedTopics.isEmpty()) { + throw new InvalidKafkaConsumerState("No topic names provided in configuration or by parameter."); + } + + validateConsumer(); + this.executorService = executorService; + return executorService.submit(() -> { + consumer.subscribe(mergedTopics, partitionsAssignedLatch); + try { + while (!closed.get()) { + ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(5)); + consumerRecords.forEach(cr -> executorService.execute(() -> function.accept(cr))); + } + } catch (WakeupException ex) { + if (!closed.get()) { + throw ex; + } + } finally { + LOGGER.info("Closing consumer" + consumerId); + consumer.close(); + } + }); + } + + public SimplePublisherBuilder createPublisherBuilder(ExecutorService executorService) { + validateConsumer(); + this.externalExecutorService = executorService; + return new SimplePublisherBuilder<>(subscriber -> { + externalExecutorService.submit(() -> { + consumer.subscribe(topicNameList, partitionsAssignedLatch); + try { + while (!closed.get()) { + ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(5)); + consumerRecords.forEach(cr -> { + KafkaMessage kafkaMessage = new KafkaMessage<>(cr); + subscriber.onNext(kafkaMessage); + }); + } + } catch (WakeupException ex) { + if (!closed.get()) { + throw ex; + } + } finally { + LOGGER.info("Closing consumer" + consumerId); + consumer.close(); + } + }); + }); + } + + private void validateConsumer() { + if (this.closed.get()) { + throw new InvalidKafkaConsumerState("Invalid consumer state, already closed"); + } + if (this.executorService != null) { + throw new InvalidKafkaConsumerState("Invalid consumer state, already consuming"); + } + } + + /** + * Blocks current thread until partitions are assigned, + * since when is consumer effectively ready to receive. + * + * @param timeout the maximum time to wait + * @param unit the time unit of the timeout argument + * @throws java.lang.InterruptedException if the current thread is interrupted while waiting + * @throws java.util.concurrent.TimeoutException if the timeout is reached + */ + public void waitForPartitionAssigment(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException { + if (!partitionsAssignedLatch.await(timeout, unit)) { + throw new TimeoutException("Timeout for subscription reached"); + } + } + + /** + * Close consumer gracefully. Stops polling loop, + * wakes possible blocked poll and shuts down executor service + */ + @Override + public void close() { + this.closed.set(true); + this.consumer.wakeup(); + Optional.ofNullable(this.executorService).ifPresent(ExecutorService::shutdown); + } + + /** + * Use supplied customGroupId if not null + * or take it from configuration if exist + * or generate random in this order + * + * @param customGroupId custom group.id, overrides group.id from configuration + */ + protected String getOrGenerateGroupId(String customGroupId) { + return Optional.ofNullable(customGroupId) + .orElse(Optional.ofNullable(properties.getProperty(KafkaConfigProperties.GROUP_ID)) + .orElse(UUID.randomUUID().toString())); + } + +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java new file mode 100644 index 00000000000..a343abbe262 --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka; + +import io.helidon.config.Config; +import org.apache.kafka.clients.producer.KafkaProducer; +import org.apache.kafka.clients.producer.ProducerRecord; +import org.apache.kafka.clients.producer.RecordMetadata; +import org.apache.kafka.common.header.Header; + +import java.io.Closeable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.logging.Logger; + +/** + * Simple Kafka producer covering basic use-cases. + * Configurable by Helidon {@link io.helidon.config.Config Config}, + * For more info about configuration see {@link KafkaConfigProperties} + *

+ * Usage: + * 

{@code new SimpleKafkaProducer("job-done-producer", Config.create())
+ *             .produce("Hello world!");
+ * }
+ * + * @param Key type + * @param Value type + * @see KafkaConfigProperties + * @see io.helidon.config.Config + */ +public class SimpleKafkaProducer implements Closeable { + + private static final Logger LOGGER = Logger.getLogger(SimpleKafkaProducer.class.getName()); + private final KafkaConfigProperties properties; + + private KafkaProducer producer; + + /** + * Kafka producer created from {@link io.helidon.config.Config config} under kafka->producerId, + * see configuration {@link KafkaConfigProperties example}. + * + * @param producerId key in configuration + * @param config Helidon {@link io.helidon.config.Config config} + * @see KafkaConfigProperties + * @see io.helidon.config.Config + */ + public SimpleKafkaProducer(String producerId, Config config) { + properties = new KafkaConfigProperties(config.get("mp.messaging.outcoming").get(producerId)); + producer = new KafkaProducer<>(properties); + } + + public SimpleKafkaProducer(Config config) { + properties = new KafkaConfigProperties(config); + producer = new KafkaProducer<>(properties); + } + + /** + * Send record to all provided topics, + * blocking until all records are acknowledged by broker + * + * @param value Will be serialized by value.serializer class + * defined in {@link KafkaConfigProperties configuration} + * @return Server acknowledged metadata about sent topics + */ + public List produce(V value) { + List> futureRecords = + this.produceAsync(null, null, null, null, value, null); + List metadataList = new ArrayList<>(futureRecords.size()); + + for (Future future : futureRecords) { + try { + metadataList.add(future.get()); + } catch (InterruptedException | ExecutionException e) { + throw new RuntimeException("Failed to send topic", e); + } + } + return metadataList; + } + + public List> produceAsync(V value) { + return this.produceAsync(null, null, null, null, value, null); + } + + /** + * Send record to all provided topics, don't wait for server acknowledgement + * + * @param customTopics Can be null, list of topics appended to the list from configuration, + * record will be sent to all topics iteratively + * @param partition Can be null, if key is also null topic is sent to random partition + * @param timestamp Can be null System.currentTimeMillis() is used then + * @param key Can be null, if not, topics are grouped to partitions by key + * @param value Will be serialized by value.serializer class defined in configuration + * @param headers Can be null, custom headers for additional meta information if needed + * @return Futures of server acknowledged metadata about sent topics + */ + public List> produceAsync(List customTopics, + Integer partition, + Long timestamp, + K key, + V value, + Iterable
headers) { + + List mergedTopics = new ArrayList<>(); + mergedTopics.addAll(properties.getTopicNameList()); + mergedTopics.addAll(Optional.ofNullable(customTopics).orElse(Collections.emptyList())); + + if (mergedTopics.isEmpty()) { + LOGGER.warning("No topic names provided in configuration or by parameter. Nothing sent."); + return Collections.emptyList(); + } + + List> recordMetadataFutures = new ArrayList<>(mergedTopics.size()); + + for (String topic : mergedTopics) { + ProducerRecord record = new ProducerRecord<>(topic, partition, timestamp, key, value, headers); + LOGGER.fine(String.format("Sending topic: %s to partition %d", topic, partition)); + recordMetadataFutures.add(producer.send(record)); + } + return recordMetadataFutures; + } + + @Override + public void close() { + producer.close(); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java new file mode 100644 index 00000000000..12203ce1778 --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka.connector; + +import io.helidon.common.configurable.ThreadPoolSupplier; +import io.helidon.messaging.kafka.SimpleKafkaConsumer; +import io.helidon.microprofile.config.MpConfig; +import org.eclipse.microprofile.config.Config; +import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.messaging.spi.Connector; +import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; +import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; + +import javax.enterprise.context.ApplicationScoped; +import javax.enterprise.context.BeforeDestroyed; +import javax.enterprise.event.Observes; + +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; + +/** + * Partial implementation of Connector as described in the MicroProfile Reactive Messaging Specification + */ +@ApplicationScoped +@Connector(KafkaConnectorFactory.CONNECTOR_NAME) +public class KafkaConnectorFactory implements IncomingConnectorFactory { + + public static final String CONNECTOR_NAME = "helidon-kafka"; + + private List> consumers = new CopyOnWriteArrayList<>(); + + public void terminate(@Observes @BeforeDestroyed(ApplicationScoped.class) Object event) { + consumers.forEach(SimpleKafkaConsumer::close); + } + + public List> getConsumers() { + return consumers; + } + + @Override + public PublisherBuilder> getPublisherBuilder(Config config) { + io.helidon.config.Config config1 = ((MpConfig) config).helidonConfig(); + SimpleKafkaConsumer simpleKafkaConsumer = + new SimpleKafkaConsumer<>(config1); + consumers.add(simpleKafkaConsumer); + return simpleKafkaConsumer.createPublisherBuilder(ThreadPoolSupplier.create(config1.get("executor-service")).get()); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java new file mode 100644 index 00000000000..b794989bc0a --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka.connector; + +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.eclipse.microprofile.reactive.messaging.Message; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; + +/** + * Kafka specific MP messaging message + * + * @param kafka record key type + * @param kafka record value type + */ +public class KafkaMessage implements Message> { + + private ConsumerRecord consumerRecord; + + public KafkaMessage(ConsumerRecord consumerRecord) { + this.consumerRecord = consumerRecord; + } + + @Override + public ConsumerRecord getPayload() { + return consumerRecord; + } + + @Override + public CompletionStage ack() { + //TODO: implement acknowledge + return new CompletableFuture<>(); + } + + @Override + public C unwrap(Class unwrapType) { + if (consumerRecord.getClass().isAssignableFrom(unwrapType)) { + return (C) consumerRecord; + } else { + throw new IllegalArgumentException("Can't unwrap to " + unwrapType.getName()); + } + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java new file mode 100644 index 00000000000..7f9f88f1a5d --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka.connector; + +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; + +import java.util.function.Consumer; + +/** + * Reactive streams publisher using {@link java.util.function.Consumer} instead of reactive streams + * + * @param kafka record key type + * @param kafka record value type + */ +public class SimplePublisher implements Publisher> { + + private Consumer>> publisher; + + public SimplePublisher(Consumer>> publisher) { + this.publisher = publisher; + } + + @Override + public void subscribe(Subscriber> s) { + publisher.accept(s); + } +} diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java new file mode 100644 index 00000000000..5dcd88542fb --- /dev/null +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.messaging.kafka.connector; + +import org.eclipse.microprofile.reactive.streams.operators.CompletionRunner; +import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder; +import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; +import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder; +import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine; +import org.reactivestreams.Processor; +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; + +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletionStage; +import java.util.function.BiConsumer; +import java.util.function.BinaryOperator; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.function.Supplier; +import java.util.stream.Collector; + +/** + * Simple stub to create MicroProfile Reactive Messaging connector without reactive streams + * + * @param kafka record key type + * @param kafka record value type + */ +public class SimplePublisherBuilder implements PublisherBuilder> { + + private Consumer>> publisher; + + public SimplePublisherBuilder(Consumer>> publisher) { + this.publisher = publisher; + } + + @Override + public Publisher> buildRs() { + //TODO: Implement ReactiveStreamsEngine instead if simple stub + return new SimplePublisher(publisher); + } + + @Override + public Publisher> buildRs(ReactiveStreamsEngine engine) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder map(Function, ? extends R> mapper) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder flatMap(Function, ? extends PublisherBuilder> mapper) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder flatMapRsPublisher(Function, ? extends Publisher> mapper) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder flatMapCompletionStage(Function, ? extends CompletionStage> mapper) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder flatMapIterable(Function, ? extends Iterable> mapper) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> filter(Predicate> predicate) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> distinct() { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> limit(long maxSize) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> skip(long n) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> takeWhile(Predicate> predicate) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> dropWhile(Predicate> predicate) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> peek(Consumer> consumer) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onError(Consumer errorHandler) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onTerminate(Runnable action) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onComplete(Runnable action) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner forEach(Consumer> action) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner ignore() { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner cancel() { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner> reduce(KafkaMessage identity, BinaryOperator> accumulator) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner>> reduce(BinaryOperator> accumulator) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner>> findFirst() { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner collect(Collector, A, R> collector) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner collect(Supplier supplier, BiConsumer> accumulator) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner>> toList() { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onErrorResume(Function> errorHandler) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onErrorResumeWith(Function>> errorHandler) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder> onErrorResumeWithRsPublisher(Function>> errorHandler) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner to(Subscriber> subscriber) { + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner to(SubscriberBuilder, ? extends R> subscriber) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder via(ProcessorBuilder, ? extends R> processor) { + throw new UnsupportedOperationException(); + } + + @Override + public PublisherBuilder via(Processor, ? extends R> processor) { + throw new UnsupportedOperationException(); + } + + +} diff --git a/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java new file mode 100644 index 00000000000..862ab087b8b --- /dev/null +++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java @@ -0,0 +1,160 @@ +package io.helidon.messaging.kafka; + +import com.salesforce.kafka.test.junit5.SharedKafkaTestResource; +import io.helidon.config.Config; +import io.helidon.config.ConfigSources; +import org.apache.kafka.clients.producer.RecordMetadata; +import org.apache.kafka.common.serialization.LongDeserializer; +import org.apache.kafka.common.serialization.LongSerializer; +import org.apache.kafka.common.serialization.StringDeserializer; +import org.apache.kafka.common.serialization.StringSerializer; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + + +public class SimpleKafkaTest { + + public static final String TEST_PRODUCER = "test-producer"; + public static final String TEST_CONSUMER_1 = "test-consumer-1"; + public static final String TEST_CONSUMER_2 = "test-consumer-2"; + public static final String TEST_MESSAGE = "this is a test message"; + + @RegisterExtension + public static final SharedKafkaTestResource kafkaResource = new SharedKafkaTestResource(); + public static final String TEST_TOPIC = "graph-done"; + + @BeforeAll + static void setUp() { + kafkaResource.getKafkaTestUtils().createTopic(TEST_TOPIC, 10, (short) 1); + } + + @Test + public void sendAndReceive() throws ExecutionException, InterruptedException, TimeoutException { + Properties p = new Properties(); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".topic", TEST_TOPIC); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName()); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".topic", TEST_TOPIC); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".key.deserializer", LongDeserializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".value.deserializer", StringDeserializer.class.getName()); + Config config = Config.builder() + .sources(ConfigSources.create(p)) + .build(); + + // Consumer + SimpleKafkaConsumer consumer = new SimpleKafkaConsumer<>(TEST_CONSUMER_1, config); + Future consumerClosedFuture = consumer.consumeAsync(r -> { + assertEquals(TEST_MESSAGE, r.value()); + consumer.close(); + }); + + consumer.waitForPartitionAssigment(10, TimeUnit.SECONDS); + + // Producer + SimpleKafkaProducer producer = new SimpleKafkaProducer<>(TEST_PRODUCER, config); + producer.produceAsync(TEST_MESSAGE); + + try { + consumerClosedFuture.get(10, TimeUnit.SECONDS); + producer.close(); + } catch (TimeoutException e) { + fail("Didn't receive test message in time"); + } + } + + @Test + public void queueBySameConsumerGroup() throws ExecutionException, InterruptedException, TimeoutException { + final String TEST_GROUP = "XXX"; + + Properties p = new Properties(); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".topic", TEST_TOPIC); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName()); + p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".topic", TEST_TOPIC); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".group.id", TEST_GROUP); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".key.deserializer", LongDeserializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".value.deserializer", StringDeserializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".topic", TEST_TOPIC); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".group.id", TEST_GROUP); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".key.deserializer", LongDeserializer.class.getName()); + p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".value.deserializer", StringDeserializer.class.getName()); + Config config = Config.builder() + .sources(ConfigSources.create(p)) + .build(); + + List receiviedByConsumer1 = Collections.synchronizedList(new ArrayList<>(4)); + List receiviedByConsumer2 = Collections.synchronizedList(new ArrayList<>(4)); + + CountDownLatch messagesCountingLatch = new CountDownLatch(4); + + // Consumer 1 + SimpleKafkaConsumer consumer1 = new SimpleKafkaConsumer<>(TEST_CONSUMER_1, config); + consumer1.consumeAsync(r -> { + messagesCountingLatch.countDown(); + receiviedByConsumer1.add(r.value()); + }); + + // Consumer 2 + SimpleKafkaConsumer consumer2 = new SimpleKafkaConsumer<>(TEST_CONSUMER_2, config); + consumer2.consumeAsync(r -> { + messagesCountingLatch.countDown(); + receiviedByConsumer2.add(r.value()); + }); + + // Wait till all consumers are ready + consumer1.waitForPartitionAssigment(10, TimeUnit.SECONDS); + consumer2.waitForPartitionAssigment(10, TimeUnit.SECONDS); + + // Producer + SimpleKafkaProducer producer = new SimpleKafkaProducer<>(TEST_PRODUCER, config); + List> producerFutures = new ArrayList<>(4); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 1)); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 2)); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 3)); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 4)); + + // Wait for all sent(this is example usage, sent doesn't mean delivered) + producerFutures.forEach(f -> { + try { + f.get(); + } catch (InterruptedException | ExecutionException e) { + fail(e); + } + }); + + // Wait till 4 records are delivered + assertTrue(messagesCountingLatch.await(10, TimeUnit.SECONDS) + , "All messages not delivered in time"); + + consumer1.close(); + consumer2.close(); + producer.close(); + + assertFalse(receiviedByConsumer1.isEmpty()); + assertFalse(receiviedByConsumer2.isEmpty()); + assertTrue(receiviedByConsumer1.stream().noneMatch(receiviedByConsumer2::contains)); + assertTrue(receiviedByConsumer2.stream().noneMatch(receiviedByConsumer1::contains)); + } + +} diff --git a/messaging/kafka/src/test/resources/logging.properties b/messaging/kafka/src/test/resources/logging.properties new file mode 100644 index 00000000000..6143051b021 --- /dev/null +++ b/messaging/kafka/src/test/resources/logging.properties @@ -0,0 +1,31 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +handlers=java.util.logging.ConsoleHandler +java.util.logging.SimpleFormatter.format=%1$tH:%1$tM:%1$tS %4$s %3$s: %5$s%6$s%n +java.util.logging.ConsoleHandler.level=INFO +.level=INFO + +# Known issue with meta.properties in embedded kafka server +kafka.server.BrokerMetadataCheckpoint.level=SEVERE +# Hide whole configuration print-out +org.apache.kafka.clients.producer.ProducerConfig.level=WARNING +org.apache.kafka.clients.consumer.ConsumerConfig.level=WARNING +# Embedded kafka server exhausting logs +kafka.level=WARNING +org.apache.kafka.level=WARNING +org.apache.zookeeper.level=SEVERE +com.salesforce.kafka.level=SEVERE diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml new file mode 100644 index 00000000000..49b22daf457 --- /dev/null +++ b/microprofile/messaging/pom.xml @@ -0,0 +1,116 @@ + + + + + 4.0.0 + + io.helidon.microprofile + helidon-microprofile-project + 1.3.2-SNAPSHOT + + + helidon-microprofile-messaging + Helidon Microprofile Messaging + The microprofile messaging implementation + + + + javax.enterprise + cdi-api + provided + + + + javax.activation + javax.activation-api + provided + + + + org.eclipse.microprofile.reactive.messaging + microprofile-reactive-messaging-api + 1.0 + + + + io.helidon.microprofile.config + helidon-microprofile-config + + + io.helidon.microprofile.config + helidon-microprofile-config-cdi + + + io.helidon.microprofile.server + helidon-microprofile-server + + + org.jboss.weld.se + weld-se-core + + + org.slf4j + slf4j-api + + + + org.slf4j + slf4j-jdk14 + + + io.helidon.messaging.connectors + kafka-connector + 1.3.2-SNAPSHOT + test + + + io.helidon.microprofile.bundles + internal-test-libs + test + + + io.reactivex.rxjava2 + rxjava + test + + + org.jboss.weld + weld-junit5 + test + + + com.salesforce.kafka.test + kafka-junit5 + 3.1.1 + test + + + + org.slf4j + slf4j-jdk14 + 1.7.28 + test + + + diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java new file mode 100644 index 00000000000..143918a8e31 --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import io.helidon.microprofile.config.MpConfig; +import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import javax.enterprise.context.spi.Context; +import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; + +import java.lang.reflect.Method; +import java.util.Map; + +/** + * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming} + * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method + */ +public class IncomingSubscriber implements Subscriber> { + private Object beanInstance; + private Bean bean; + private final Method method; + private final String channelName; + private Map> incomingConnectorFactories; + private BeanManager beanManager; + private io.helidon.config.Config config; + + public IncomingSubscriber(AnnotatedMethod method, Map> incomingConnectorFactories) { + this.method = method.getJavaMember(); + this.channelName = method.getAnnotation(Incoming.class).value(); + this.incomingConnectorFactories = incomingConnectorFactories; + } + + public void subscribe(BeanManager beanManager, io.helidon.config.Config config) { + this.beanInstance = getBeanInstance(bean, beanManager); + this.beanManager = beanManager; + this.config = config; + io.helidon.config.Config channelConfig = config.get("mp.messaging.incoming").get(channelName); + + String connectorName = channelConfig.get("connector").asString().get(); + ((IncomingConnectorFactory) getBeanInstance(incomingConnectorFactories.get(connectorName), beanManager)) + .getPublisherBuilder(MpConfig.builder().config(channelConfig).build()) + .buildRs() + .subscribe(this); + } + + public void setDeclaringBean(Bean bean) { + this.bean = bean; + } + + public Class getDeclaringType() { + return method.getDeclaringClass(); + } + + @Override + public void onNext(Message message) { + try { + //io.helidon.common.context.Contexts.runInContext(io.helidon.common.context.Context, java.lang.Runnable) + // + method.invoke(beanInstance, message); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Override + public void onError(Throwable t) { + //TODO: Error propagation + } + + @Override + public void onSubscribe(Subscription s) { + } + + @Override + public void onComplete() { + } + + private Object getBeanInstance(Bean bean, BeanManager beanManager) { + Context context = beanManager.getContext(bean.getScope()); + Object instance = context.get(bean); + if (instance == null) { + CreationalContext creationalContext = beanManager.createCreationalContext(bean); + return beanManager.getReference(bean, bean.getBeanClass(), creationalContext); + } + return instance; + } + +} diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java new file mode 100644 index 00000000000..0ae81b04907 --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import io.helidon.config.Config; +import io.helidon.microprofile.config.MpConfig; +import org.eclipse.microprofile.config.ConfigProvider; +import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.spi.Connector; +import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; + +import javax.enterprise.event.Observes; +import javax.enterprise.inject.spi.AfterDeploymentValidation; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; +import javax.enterprise.inject.spi.Extension; +import javax.enterprise.inject.spi.ProcessAnnotatedType; +import javax.enterprise.inject.spi.ProcessManagedBean; +import javax.enterprise.inject.spi.WithAnnotations; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; + +/** + * Extension with partial implementation of MicroProfile Reactive Messaging Specification + */ +public class MessagingCdiExtension implements Extension { + private static final Logger LOGGER = Logger.getLogger(MessagingCdiExtension.class.getName()); + + public List incomingSubscribers = new ArrayList<>(); + + public Map> incomingConnectorFactoryMap = new HashMap<>(); + + private void registerIncomings(@Observes @WithAnnotations({Incoming.class}) ProcessAnnotatedType pat) { + LOGGER.info("Registering incoming methods"); + pat.getAnnotatedType().getMethods().forEach(m -> incomingSubscribers.add(new IncomingSubscriber(m, incomingConnectorFactoryMap))); + } + + public void onProcessBean(@Observes ProcessManagedBean event) { + Class beanType = event.getBean().getBeanClass(); + // Lookup connectors + Connector annotation = event.getAnnotatedBeanClass().getAnnotation(Connector.class); + if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { + incomingConnectorFactoryMap.put(annotation.value(), event.getBean()); + } + // Gather bean references + incomingSubscribers.stream() + .filter(m -> m.getDeclaringType() == beanType) + .forEach(m -> m.setDeclaringBean(event.getBean())); + } + + public void onAfterDeploymentValidation(@Observes AfterDeploymentValidation event, BeanManager beanManager) { + Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig(); + incomingSubscribers.forEach(m -> m.subscribe(beanManager, config)); + } + +} diff --git a/microprofile/messaging/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension b/microprofile/messaging/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension new file mode 100644 index 00000000000..463018c73d9 --- /dev/null +++ b/microprofile/messaging/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension @@ -0,0 +1,17 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +io.helidon.microprofile.messaging.MessagingCdiExtension \ No newline at end of file diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java new file mode 100644 index 00000000000..d8fdb8ead89 --- /dev/null +++ b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.Message; + +import javax.enterprise.context.ApplicationScoped; + +import java.util.concurrent.CountDownLatch; + +@ApplicationScoped +public class KafkaConsumingTestBean { + + public static int EXPECTED_TOPIC_RECORD_NUMBER = 3; + //Two methods -> two consumers of same topic + public static CountDownLatch latch = new CountDownLatch(EXPECTED_TOPIC_RECORD_NUMBER * 2); + + @Incoming("test-channel") + public void receiveMethod1(Message> msg) { + latch.countDown(); + System.out.println("Received message!!! ->" + msg.getPayload().value()); + } + + + @Incoming("test-channel") + public void receiveMethod2(Message> msg) { + latch.countDown(); + System.out.println("Received message in second consumer!!! ->" + msg.getPayload().value()); + } +} diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java new file mode 100644 index 00000000000..03436fca8ce --- /dev/null +++ b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import com.salesforce.kafka.test.junit5.SharedKafkaTestResource; +import io.helidon.config.Config; +import io.helidon.config.ConfigSources; +import io.helidon.messaging.kafka.SimpleKafkaProducer; +import io.helidon.messaging.kafka.connector.KafkaConnectorFactory; +import io.helidon.microprofile.config.MpConfig; +import io.helidon.microprofile.config.MpConfigProviderResolver; +import io.helidon.microprofile.server.Server; +import org.apache.kafka.clients.producer.RecordMetadata; +import org.apache.kafka.common.serialization.LongDeserializer; +import org.apache.kafka.common.serialization.LongSerializer; +import org.apache.kafka.common.serialization.StringDeserializer; +import org.apache.kafka.common.serialization.StringSerializer; +import org.eclipse.microprofile.reactive.messaging.spi.Connector; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import javax.enterprise.inject.se.SeContainer; +import javax.enterprise.inject.se.SeContainerInitializer; + +import java.io.IOException; +import java.io.InputStream; +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.logging.LogManager; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +class MessagingCdiExtensionTest { + + private static SeContainer cdiContainer; + + @RegisterExtension + public static final SharedKafkaTestResource kafkaResource = new SharedKafkaTestResource(); + public static final String TEST_TOPIC = "graph-done"; + public static final String TEST_MESSAGE = "this is first test message"; + + + private static final Connector CONNECTOR_LITERAL = new Connector() { + + @Override + public Class annotationType() { + return Connector.class; + } + + @Override + public String value() { + return KafkaConnectorFactory.CONNECTOR_NAME; + } + }; + + @BeforeAll + public synchronized static void startCdiContainer() { + setupLogging(); + Properties p = new Properties(); + p.setProperty("mp.messaging.incoming.test-channel.connector", KafkaConnectorFactory.CONNECTOR_NAME); + p.setProperty("mp.messaging.incoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.incoming.test-channel.topic", TEST_TOPIC); + p.setProperty("mp.messaging.incoming.test-channel.key.deserializer", LongDeserializer.class.getName()); + p.setProperty("mp.messaging.incoming.test-channel.value.deserializer", StringDeserializer.class.getName()); + + Config config = Config.builder() + .sources(ConfigSources.create(p)) + .build(); + + kafkaResource.getKafkaTestUtils().createTopic(TEST_TOPIC, 10, (short) 1); + + final Server.Builder builder = Server.builder(); + assertNotNull(builder); + builder.config(config); + MpConfigProviderResolver.instance().registerConfig((MpConfig) MpConfig.builder().config(config).build(), Thread.currentThread().getContextClassLoader()); + final SeContainerInitializer initializer = SeContainerInitializer.newInstance(); + assertThat(initializer, is(notNullValue())); + initializer.addBeanClasses(KafkaConsumingTestBean.class); + initializer.addBeanClasses(KafkaConnectorFactory.class); + cdiContainer = initializer.initialize(); + + cdiContainer.select(KafkaConnectorFactory.class).stream().forEach(f -> f.getConsumers().forEach(c -> { + try { + c.waitForPartitionAssigment(10, TimeUnit.SECONDS); + } catch (InterruptedException | TimeoutException e) { + fail(e); + } + })); + + } + + @AfterAll + public synchronized static void shutDownCdiContainer() { + if (cdiContainer != null) { + cdiContainer.close(); + } + } + + @Test + void name() throws InterruptedException { + Properties p = new Properties(); + p.setProperty("mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString()); + p.setProperty("mp.messaging.outcoming.test-channel.topic", TEST_TOPIC); + p.setProperty("mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName()); + p.setProperty("mp.messaging.outcoming.test-channel.value.serializer", StringSerializer.class.getName()); + + Config config = Config.builder() + .sources(ConfigSources.create(p)) + .build(); + + cdiContainer.select(KafkaConnectorFactory.class, CONNECTOR_LITERAL).stream() + .forEach(f -> f.getConsumers().forEach(c -> { + try { + c.waitForPartitionAssigment(10, TimeUnit.SECONDS); + } catch (InterruptedException | TimeoutException e) { + fail(e); + } + })); + + // Producer + SimpleKafkaProducer producer = new SimpleKafkaProducer<>(config.get("mp.messaging.outcoming.test-channel")); + List> producerFutures = new ArrayList<>(3); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 1)); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 2)); + producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 3)); + + // Wait for all sent(this is example usage, sent doesn't mean delivered) + producerFutures.forEach(f -> { + try { + f.get(); + } catch (InterruptedException | ExecutionException e) { + fail(e); + } + }); + + // Wait till 3 records are delivered + assertTrue(KafkaConsumingTestBean.latch.await(15, TimeUnit.SECONDS) + , "All messages not delivered in time, number of unreceived messages: " + + KafkaConsumingTestBean.latch.getCount()); + producer.close(); + } + + /** + * Configure logging from logging.properties file. + */ + private static void setupLogging() { + try (InputStream is = MessagingCdiExtensionTest.class.getResourceAsStream("/logging.properties")) { + LogManager.getLogManager().readConfiguration(is); + } catch (IOException e) { + fail(e); + } + } +} \ No newline at end of file diff --git a/microprofile/messaging/src/test/resources/application.yaml b/microprofile/messaging/src/test/resources/application.yaml new file mode 100644 index 00000000000..d9ce9c99995 --- /dev/null +++ b/microprofile/messaging/src/test/resources/application.yaml @@ -0,0 +1,28 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +mp.messaging: + incoming: + test-channel: + connector: helidon-kafka + bootstrap.servers: localhost:9092 + topic: graph-done + key.deserializer: org.apache.kafka.common.serialization.LongDeserializer + value.deserializer: org.apache.kafka.common.serialization.StringDeserializer + +mp.messaging.connector: + helidon-kafka: + bootstrap.servers: localhost:9092 diff --git a/microprofile/messaging/src/test/resources/logging.properties b/microprofile/messaging/src/test/resources/logging.properties new file mode 100644 index 00000000000..6143051b021 --- /dev/null +++ b/microprofile/messaging/src/test/resources/logging.properties @@ -0,0 +1,31 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +handlers=java.util.logging.ConsoleHandler +java.util.logging.SimpleFormatter.format=%1$tH:%1$tM:%1$tS %4$s %3$s: %5$s%6$s%n +java.util.logging.ConsoleHandler.level=INFO +.level=INFO + +# Known issue with meta.properties in embedded kafka server +kafka.server.BrokerMetadataCheckpoint.level=SEVERE +# Hide whole configuration print-out +org.apache.kafka.clients.producer.ProducerConfig.level=WARNING +org.apache.kafka.clients.consumer.ConsumerConfig.level=WARNING +# Embedded kafka server exhausting logs +kafka.level=WARNING +org.apache.kafka.level=WARNING +org.apache.zookeeper.level=SEVERE +com.salesforce.kafka.level=SEVERE From 783b2bc282fb54cb230056a2c047b3a7008b7c36 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Thu, 31 Oct 2019 11:13:33 +0100 Subject: [PATCH 02/66] Proper context propagation Signed-off-by: Daniel Kec --- .../messaging/kafka/SimpleKafkaConsumer.java | 2 +- .../connector/KafkaConnectorFactory.java | 25 ++++++++++++++----- .../IncomingSubscriber.java | 20 +++++++++------ .../MessagingCdiExtensionTest.java | 2 +- 4 files changed, 34 insertions(+), 15 deletions(-) diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java index 1dab68af266..53eaa4c5189 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java @@ -170,7 +170,7 @@ public SimplePublisherBuilder createPublisherBuilder(ExecutorService execu ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(5)); consumerRecords.forEach(cr -> { KafkaMessage kafkaMessage = new KafkaMessage<>(cr); - subscriber.onNext(kafkaMessage); + executorService.execute(() -> subscriber.onNext(kafkaMessage)); }); } } catch (WakeupException ex) { diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java index 12203ce1778..4c3a46905c7 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java @@ -17,9 +17,9 @@ package io.helidon.messaging.kafka.connector; import io.helidon.common.configurable.ThreadPoolSupplier; +import io.helidon.config.Config; import io.helidon.messaging.kafka.SimpleKafkaConsumer; import io.helidon.microprofile.config.MpConfig; -import org.eclipse.microprofile.config.Config; import org.eclipse.microprofile.reactive.messaging.Message; import org.eclipse.microprofile.reactive.messaging.spi.Connector; import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; @@ -42,6 +42,7 @@ public class KafkaConnectorFactory implements IncomingConnectorFactory { public static final String CONNECTOR_NAME = "helidon-kafka"; private List> consumers = new CopyOnWriteArrayList<>(); + private ThreadPoolSupplier threadPoolSupplier = null; public void terminate(@Observes @BeforeDestroyed(ApplicationScoped.class) Object event) { consumers.forEach(SimpleKafkaConsumer::close); @@ -52,11 +53,23 @@ public List> getConsumers() { } @Override - public PublisherBuilder> getPublisherBuilder(Config config) { - io.helidon.config.Config config1 = ((MpConfig) config).helidonConfig(); - SimpleKafkaConsumer simpleKafkaConsumer = - new SimpleKafkaConsumer<>(config1); + public PublisherBuilder> getPublisherBuilder(org.eclipse.microprofile.config.Config config) { + Config helidonConfig = ((MpConfig) config).helidonConfig(); + SimpleKafkaConsumer simpleKafkaConsumer = new SimpleKafkaConsumer<>(helidonConfig); consumers.add(simpleKafkaConsumer); - return simpleKafkaConsumer.createPublisherBuilder(ThreadPoolSupplier.create(config1.get("executor-service")).get()); + return simpleKafkaConsumer.createPublisherBuilder(getThreadPoolSupplier(helidonConfig).get()); + } + + private ThreadPoolSupplier getThreadPoolSupplier(Config config) { + if (this.threadPoolSupplier != null) { + return this.threadPoolSupplier; + } + synchronized (this) { + if (this.threadPoolSupplier != null) { + return this.threadPoolSupplier; + } + this.threadPoolSupplier = ThreadPoolSupplier.create(config.get("executor-service")); + return threadPoolSupplier; + } } } diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java index 143918a8e31..43d80fb4032 100644 --- a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java @@ -16,6 +16,8 @@ package io.helidon.microprofile.messaging; +import io.helidon.common.context.Context; +import io.helidon.common.context.Contexts; import io.helidon.microprofile.config.MpConfig; import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Message; @@ -23,7 +25,6 @@ import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; -import javax.enterprise.context.spi.Context; import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.AnnotatedMethod; import javax.enterprise.inject.spi.Bean; @@ -31,10 +32,11 @@ import java.lang.reflect.Method; import java.util.Map; +import java.util.UUID; /** - * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming} - * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method + * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming} + * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method */ public class IncomingSubscriber implements Subscriber> { private Object beanInstance; @@ -75,9 +77,13 @@ public Class getDeclaringType() { @Override public void onNext(Message message) { try { - //io.helidon.common.context.Contexts.runInContext(io.helidon.common.context.Context, java.lang.Runnable) - // - method.invoke(beanInstance, message); + Context parentContext = Context.create(); + Context context = Context + .builder() + .parent(parentContext) + .id(parentContext.id() + ":message-" + UUID.randomUUID().toString()) + .build(); + Contexts.runInContext(context, () -> method.invoke(beanInstance, message)); } catch (Exception e) { throw new RuntimeException(e); } @@ -97,7 +103,7 @@ public void onComplete() { } private Object getBeanInstance(Bean bean, BeanManager beanManager) { - Context context = beanManager.getContext(bean.getScope()); + javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope()); Object instance = context.get(bean); if (instance == null) { CreationalContext creationalContext = beanManager.createCreationalContext(bean); diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java index 03436fca8ce..b2d029bfb81 100644 --- a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java +++ b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java @@ -102,8 +102,8 @@ public synchronized static void startCdiContainer() { MpConfigProviderResolver.instance().registerConfig((MpConfig) MpConfig.builder().config(config).build(), Thread.currentThread().getContextClassLoader()); final SeContainerInitializer initializer = SeContainerInitializer.newInstance(); assertThat(initializer, is(notNullValue())); - initializer.addBeanClasses(KafkaConsumingTestBean.class); initializer.addBeanClasses(KafkaConnectorFactory.class); + initializer.addBeanClasses(KafkaConsumingTestBean.class); cdiContainer = initializer.initialize(); cdiContainer.select(KafkaConnectorFactory.class).stream().forEach(f -> f.getConsumers().forEach(c -> { From 88b37e91d1471728cbf6d7896018b04553f02971 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Thu, 31 Oct 2019 23:23:24 +0100 Subject: [PATCH 03/66] First few passable tck tests Signed-off-by: Daniel Kec --- .../kafka/KafkaConfigProperties.java | 2 +- .../messaging/kafka/SimpleKafkaProducer.java | 2 +- .../connector/SimplePublisherBuilder.java | 22 ++-- microprofile/messaging/pom.xml | 2 +- .../AbstractConnectableChannelMethod.java | 62 ++++++++++ .../ChannelRouter.java | 73 ++++++++++++ .../IncomingSubscriber.java | 82 ++++++------- .../MessagingCdiExtension.java | 47 ++++---- .../OutgoingPublisher.java | 71 +++++++++++ .../ScheduledPublisher.java | 11 ++ .../KafkaConsumingTestBean.java | 27 ++++- .../MessagingCdiExtensionTest.java | 14 ++- microprofile/tests/tck/tck-messaging/pom.xml | 111 ++++++++++++++++++ .../src/test/resources/arquillian.xml | 29 +++++ 14 files changed, 466 insertions(+), 89 deletions(-) create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java create mode 100644 microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java create mode 100644 microprofile/tests/tck/tck-messaging/pom.xml create mode 100644 microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java index ace6ef9cdc6..5ee4bbc6bff 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java @@ -39,7 +39,7 @@ * key.deserializer: org.apache.kafka.common.serialization.LongDeserializer * value.deserializer: org.apache.kafka.common.serialization.StringDeserializer * - * outcoming: + * outgoing: * test-channel: * bootstrap.servers: localhost:9092 * topic: graph-done diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java index a343abbe262..9cecda53ea0 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java @@ -63,7 +63,7 @@ public class SimpleKafkaProducer implements Closeable { * @see io.helidon.config.Config */ public SimpleKafkaProducer(String producerId, Config config) { - properties = new KafkaConfigProperties(config.get("mp.messaging.outcoming").get(producerId)); + properties = new KafkaConfigProperties(config.get("mp.messaging.outgoing").get(producerId)); producer = new KafkaProducer<>(properties); } diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java index 5dcd88542fb..0c8189591af 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java @@ -56,6 +56,18 @@ public Publisher> buildRs() { return new SimplePublisher(publisher); } + @Override + public CompletionRunner to(Subscriber> subscriber) { + //TODO: Gonna need this for outgoing + throw new UnsupportedOperationException(); + } + + @Override + public CompletionRunner to(SubscriberBuilder, ? extends R> subscriber) { + //TODO: Gonna need this for outgoing + throw new UnsupportedOperationException(); + } + @Override public Publisher> buildRs(ReactiveStreamsEngine engine) { throw new UnsupportedOperationException(); @@ -196,16 +208,6 @@ public PublisherBuilder> onErrorResumeWithRsPublisher(Functio throw new UnsupportedOperationException(); } - @Override - public CompletionRunner to(Subscriber> subscriber) { - throw new UnsupportedOperationException(); - } - - @Override - public CompletionRunner to(SubscriberBuilder, ? extends R> subscriber) { - throw new UnsupportedOperationException(); - } - @Override public PublisherBuilder via(ProcessorBuilder, ? extends R> processor) { throw new UnsupportedOperationException(); diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml index 49b22daf457..bebe8370770 100644 --- a/microprofile/messaging/pom.xml +++ b/microprofile/messaging/pom.xml @@ -92,7 +92,7 @@ io.reactivex.rxjava2 rxjava - test + org.jboss.weld diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java new file mode 100644 index 00000000000..d99ee93e9c2 --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java @@ -0,0 +1,62 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.config.Config; + +import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; + +import java.lang.reflect.Method; + +public abstract class AbstractConnectableChannelMethod { + + protected final String channelName; + + protected Bean bean; + private ChannelRouter router; + protected Method method; + protected Object beanInstance; + protected BeanManager beanManager; + protected Config config; + + public AbstractConnectableChannelMethod(String channelName, Method method, ChannelRouter router) { + this.router = router; + this.method = method; + this.channelName = channelName; + } + + protected abstract void connect(); + + public void connect(BeanManager beanManager, Config config) { + this.beanInstance = getBeanInstance(bean, beanManager); + this.beanManager = beanManager; + this.config = config; + connect(); + } + + public void setDeclaringBean(Bean bean) { + this.bean = bean; + } + + public Class getDeclaringType() { + return method.getDeclaringClass(); + } + + public String getChannelName() { + return channelName; + } + + protected Object getBeanInstance(Bean bean, BeanManager beanManager) { + javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope()); + Object instance = context.get(bean); + if (instance == null) { + CreationalContext creationalContext = beanManager.createCreationalContext(bean); + return beanManager.getReference(bean, bean.getBeanClass(), creationalContext); + } + return instance; + } + + public ChannelRouter getRouter() { + return router; + } +} diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java new file mode 100644 index 00000000000..4717fe9abe7 --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java @@ -0,0 +1,73 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.config.Config; +import io.helidon.microprofile.config.MpConfig; +import org.eclipse.microprofile.config.ConfigProvider; +import org.eclipse.microprofile.reactive.messaging.spi.Connector; +import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; +import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory; + +import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class ChannelRouter { + private List connectableBeanMethods = new ArrayList<>(); + private Map> incomingSubscriberMap = new HashMap<>(); + + private Map> incomingConnectorFactoryMap = new HashMap<>(); + private Map> outgoingConnectorFactoryMap = new HashMap<>(); + + public void registerBeanReference(Bean bean) { + connectableBeanMethods.stream() + .filter(m -> m.getDeclaringType() == bean.getBeanClass()) + .forEach(m -> m.setDeclaringBean(bean)); + } + + public void connect(BeanManager beanManager) { + Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig(); + connectableBeanMethods.forEach(m -> m.connect(beanManager, config)); + } + + void addIncomingMethod(AnnotatedMethod m) { + IncomingSubscriber incomingSubscriber = new IncomingSubscriber(m, this); + String channelName = incomingSubscriber.getChannelName(); + List namedIncomings = incomingSubscriberMap.getOrDefault(channelName, new ArrayList<>()); + namedIncomings.add(incomingSubscriber); + incomingSubscriberMap.put(channelName, namedIncomings); + connectableBeanMethods.add(incomingSubscriber); + } + + void addOutgoingMethod(AnnotatedMethod m) { + OutgoingPublisher outgoingPublisher = new OutgoingPublisher(m, this); + connectableBeanMethods.add(outgoingPublisher); + } + + void addConnectorFactory(Bean bean) { + Class beanType = bean.getBeanClass(); + Connector annotation = beanType.getAnnotation(Connector.class); + if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { + incomingConnectorFactoryMap.put(annotation.value(), bean); + } else if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { + outgoingConnectorFactoryMap.put(annotation.value(), bean); + } + } + + public List getIncomingSubscribers(String channelName) { + return incomingSubscriberMap.get(channelName); + } + + public Bean getIncomingConnectorFactory(String connectorName) { + return incomingConnectorFactoryMap.get(connectorName); + } + + public Bean getOutgoingConnectorFactory(String connectorName) { + return outgoingConnectorFactoryMap.get(connectorName); + } + +} diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java index 43d80fb4032..ed930696820 100644 --- a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java @@ -18,72 +18,73 @@ import io.helidon.common.context.Context; import io.helidon.common.context.Contexts; +import io.helidon.config.Config; +import io.helidon.config.ConfigValue; import io.helidon.microprofile.config.MpConfig; import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Message; import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; +import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; -import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.AnnotatedMethod; -import javax.enterprise.inject.spi.Bean; -import javax.enterprise.inject.spi.BeanManager; -import java.lang.reflect.Method; -import java.util.Map; import java.util.UUID; +import java.util.logging.Logger; /** * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming} * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method */ -public class IncomingSubscriber implements Subscriber> { - private Object beanInstance; - private Bean bean; - private final Method method; - private final String channelName; - private Map> incomingConnectorFactories; - private BeanManager beanManager; - private io.helidon.config.Config config; - - public IncomingSubscriber(AnnotatedMethod method, Map> incomingConnectorFactories) { - this.method = method.getJavaMember(); - this.channelName = method.getAnnotation(Incoming.class).value(); - this.incomingConnectorFactories = incomingConnectorFactories; - } +public class IncomingSubscriber extends AbstractConnectableChannelMethod implements Subscriber> { + + private static final Logger LOGGER = Logger.getLogger(IncomingSubscriber.class.getName()); + + private PublisherBuilder> publisherBuilder; - public void subscribe(BeanManager beanManager, io.helidon.config.Config config) { - this.beanInstance = getBeanInstance(bean, beanManager); - this.beanManager = beanManager; - this.config = config; - io.helidon.config.Config channelConfig = config.get("mp.messaging.incoming").get(channelName); - - String connectorName = channelConfig.get("connector").asString().get(); - ((IncomingConnectorFactory) getBeanInstance(incomingConnectorFactories.get(connectorName), beanManager)) - .getPublisherBuilder(MpConfig.builder().config(channelConfig).build()) - .buildRs() - .subscribe(this); + public IncomingSubscriber(AnnotatedMethod method, ChannelRouter router) { + super(method.getAnnotation(Incoming.class).value(), method.getJavaMember(), router); } - public void setDeclaringBean(Bean bean) { - this.bean = bean; + @Override + protected void connect() { + Config channelConfig = config.get("mp.messaging.incoming").get(channelName); + ConfigValue connectorName = channelConfig.get("connector").asString(); + if (connectorName.isPresent()) { + publisherBuilder = ((IncomingConnectorFactory) getBeanInstance(getRouter() + .getIncomingConnectorFactory(connectorName.get()), beanManager)) + .getPublisherBuilder(MpConfig.builder().config(channelConfig).build()); + + //TODO: iterate over multiple publishers + publisherBuilder.buildRs().subscribe(this); + LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", channelName, connectorName.get(), method.toString())); + } } - public Class getDeclaringType() { - return method.getDeclaringClass(); + + public PublisherBuilder> getPublisherBuilder() { + return publisherBuilder; } @Override public void onNext(Message message) { try { + final Object paramValue; + Class paramType = this.method.getParameterTypes()[0]; + if (paramType != Message.class) { + paramValue = paramType.cast(message.getPayload()); + } else { + paramValue = message; + } + Context parentContext = Context.create(); Context context = Context .builder() .parent(parentContext) .id(parentContext.id() + ":message-" + UUID.randomUUID().toString()) .build(); - Contexts.runInContext(context, () -> method.invoke(beanInstance, message)); + Contexts.runInContext(context, () -> method.invoke(beanInstance, paramValue)); } catch (Exception e) { throw new RuntimeException(e); } @@ -96,20 +97,11 @@ public void onError(Throwable t) { @Override public void onSubscribe(Subscription s) { + System.out.println(s); } @Override public void onComplete() { } - private Object getBeanInstance(Bean bean, BeanManager beanManager) { - javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope()); - Object instance = context.get(bean); - if (instance == null) { - CreationalContext creationalContext = beanManager.createCreationalContext(bean); - return beanManager.getReference(bean, bean.getBeanClass(), creationalContext); - } - return instance; - } - } diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java index 0ae81b04907..78835f52132 100644 --- a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java @@ -16,26 +16,19 @@ package io.helidon.microprofile.messaging; -import io.helidon.config.Config; -import io.helidon.microprofile.config.MpConfig; -import org.eclipse.microprofile.config.ConfigProvider; import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.Outgoing; import org.eclipse.microprofile.reactive.messaging.spi.Connector; import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; import javax.enterprise.event.Observes; import javax.enterprise.inject.spi.AfterDeploymentValidation; -import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.BeanManager; import javax.enterprise.inject.spi.Extension; import javax.enterprise.inject.spi.ProcessAnnotatedType; import javax.enterprise.inject.spi.ProcessManagedBean; import javax.enterprise.inject.spi.WithAnnotations; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import java.util.logging.Logger; /** @@ -44,31 +37,41 @@ public class MessagingCdiExtension implements Extension { private static final Logger LOGGER = Logger.getLogger(MessagingCdiExtension.class.getName()); - public List incomingSubscribers = new ArrayList<>(); + private ChannelRouter channelRouter = new ChannelRouter(); - public Map> incomingConnectorFactoryMap = new HashMap<>(); - - private void registerIncomings(@Observes @WithAnnotations({Incoming.class}) ProcessAnnotatedType pat) { + private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, Outgoing.class}) ProcessAnnotatedType pat) { LOGGER.info("Registering incoming methods"); - pat.getAnnotatedType().getMethods().forEach(m -> incomingSubscribers.add(new IncomingSubscriber(m, incomingConnectorFactoryMap))); + pat.getAnnotatedType().getMethods() + .stream() + .filter(m -> m.isAnnotationPresent(Incoming.class)) + .forEach(m -> channelRouter.addIncomingMethod(m)); + + LOGGER.info("Registering outgoing methods"); + pat.getAnnotatedType().getMethods() + .stream() + .filter(m -> m.isAnnotationPresent(Outgoing.class)) + .forEach(m -> channelRouter.addOutgoingMethod(m)); } public void onProcessBean(@Observes ProcessManagedBean event) { - Class beanType = event.getBean().getBeanClass(); + LOGGER.info("Lookup connectors"); // Lookup connectors Connector annotation = event.getAnnotatedBeanClass().getAnnotation(Connector.class); - if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { - incomingConnectorFactoryMap.put(annotation.value(), event.getBean()); + if (IncomingConnectorFactory.class.isAssignableFrom(event.getBean().getBeanClass()) && null != annotation) { + channelRouter.addConnectorFactory(event.getBean()); } + LOGGER.info("Gather references"); // Gather bean references - incomingSubscribers.stream() - .filter(m -> m.getDeclaringType() == beanType) - .forEach(m -> m.setDeclaringBean(event.getBean())); + //TODO: Multiple bean references(not singleton) + channelRouter.registerBeanReference(event.getBean()); + LOGGER.info("References gathered"); } - public void onAfterDeploymentValidation(@Observes AfterDeploymentValidation event, BeanManager beanManager) { - Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig(); - incomingSubscribers.forEach(m -> m.subscribe(beanManager, config)); + public void makeConnections(@Observes AfterDeploymentValidation event, BeanManager beanManager) { + LOGGER.info("Final connect"); + // Subscribe subscribers and publish publishers + channelRouter.connect(beanManager); + LOGGER.info("All connected"); } } diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java new file mode 100644 index 00000000000..43e200ff74b --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java @@ -0,0 +1,71 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.config.Config; +import io.helidon.config.ConfigValue; +import io.helidon.microprofile.config.MpConfig; +import io.reactivex.Flowable; +import io.reactivex.schedulers.Schedulers; +import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.messaging.Outgoing; +import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory; +import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder; +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; + +import javax.enterprise.inject.spi.AnnotatedMethod; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +//TODO: remove publisher implementation, it doesnt make sense here(rename class too) +public class OutgoingPublisher extends AbstractConnectableChannelMethod implements Publisher> { + + private static final Logger LOGGER = Logger.getLogger(OutgoingPublisher.class.getName()); + + private List>> subscriberList = new ArrayList<>(); + private SubscriberBuilder, Void> subscriberBuilder; + + public OutgoingPublisher(AnnotatedMethod method, ChannelRouter router) { + super(method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router); + } + + public void connect() { + + try { + //TODO: Types? + Publisher result = (Publisher) method.invoke(beanInstance); + + Config channelConfig = config.get("mp.messaging.outgoing").get(channelName); + ConfigValue connectorName = channelConfig.get("connector").asString(); + if (connectorName.isPresent()) { + subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter() + .getOutgoingConnectorFactory(connectorName.get()), beanManager)) + .getSubscriberBuilder(MpConfig.builder().config(channelConfig).build()); + result.subscribe(subscriberBuilder.build()); + } else { + // Connect to Incoming methods + List incomingSubscribers = getRouter().getIncomingSubscribers(getChannelName()); + if (incomingSubscribers != null) { + for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) { + //TODO: get rid of reactivex + ((Flowable)result).observeOn(Schedulers.computation()).subscribe(o -> s.onNext(Message.of(o))); + } + } + + } + + + } catch (IllegalAccessException | InvocationTargetException e) { + throw new RuntimeException(e); + } + + + } + + @Override + public void subscribe(Subscriber> subscriber) { + + } +} diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java new file mode 100644 index 00000000000..d7c26b3bec8 --- /dev/null +++ b/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java @@ -0,0 +1,11 @@ +package io.helidon.microprofile.messaging; + +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; + +public class ScheduledPublisher implements Publisher { + @Override + public void subscribe(Subscriber s) { + + } +} diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java index d8fdb8ead89..06c0f405180 100644 --- a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java +++ b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java @@ -16,12 +16,16 @@ package io.helidon.microprofile.messaging; +import io.reactivex.Flowable; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.messaging.Outgoing; +import org.reactivestreams.Publisher; import javax.enterprise.context.ApplicationScoped; +import java.util.Arrays; import java.util.concurrent.CountDownLatch; @ApplicationScoped @@ -29,18 +33,29 @@ public class KafkaConsumingTestBean { public static int EXPECTED_TOPIC_RECORD_NUMBER = 3; //Two methods -> two consumers of same topic - public static CountDownLatch latch = new CountDownLatch(EXPECTED_TOPIC_RECORD_NUMBER * 2); + public static CountDownLatch testChannelLatch = new CountDownLatch(EXPECTED_TOPIC_RECORD_NUMBER * 2); + public static CountDownLatch selfCallLatch = new CountDownLatch(2); @Incoming("test-channel") public void receiveMethod1(Message> msg) { - latch.countDown(); - System.out.println("Received message!!! ->" + msg.getPayload().value()); + testChannelLatch.countDown(); + System.out.println("Received message ->" + msg.getPayload().value()); } - @Incoming("test-channel") public void receiveMethod2(Message> msg) { - latch.countDown(); - System.out.println("Received message in second consumer!!! ->" + msg.getPayload().value()); + testChannelLatch.countDown(); + System.out.println("Received message in second consumer ->" + msg.getPayload().value()); + } + + @Outgoing("self-call-channel") + public Publisher produceMessage() { + return Flowable.fromIterable(Arrays.asList("test1", "test2")); + } + + @Incoming("self-call-channel") + public void receiveFromSelfMethod(String msg) { + selfCallLatch.countDown(); + System.out.println("Received message from myself ->" + msg); } } diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java index b2d029bfb81..fc49e7d5fd7 100644 --- a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java +++ b/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java @@ -124,7 +124,7 @@ public synchronized static void shutDownCdiContainer() { } @Test - void name() throws InterruptedException { + void incomingKafkaTest() throws InterruptedException { Properties p = new Properties(); p.setProperty("mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString()); p.setProperty("mp.messaging.outcoming.test-channel.topic", TEST_TOPIC); @@ -161,12 +161,20 @@ void name() throws InterruptedException { }); // Wait till 3 records are delivered - assertTrue(KafkaConsumingTestBean.latch.await(15, TimeUnit.SECONDS) + assertTrue(KafkaConsumingTestBean.testChannelLatch.await(15, TimeUnit.SECONDS) , "All messages not delivered in time, number of unreceived messages: " - + KafkaConsumingTestBean.latch.getCount()); + + KafkaConsumingTestBean.testChannelLatch.getCount()); producer.close(); } + @Test + void directOutgoingIncomingTest() throws InterruptedException { + // Wait till 2 messages are delivered + assertTrue(KafkaConsumingTestBean.selfCallLatch.await(15, TimeUnit.SECONDS) + , "All messages not delivered in time, number of unreceived messages: " + + KafkaConsumingTestBean.selfCallLatch.getCount()); + } + /** * Configure logging from logging.properties file. */ diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml new file mode 100644 index 00000000000..9b8420a0caf --- /dev/null +++ b/microprofile/tests/tck/tck-messaging/pom.xml @@ -0,0 +1,111 @@ + + + + + 4.0.0 + + io.helidon.microprofile.tests + tck-project + 1.3.2-SNAPSHOT + + tck-messaging + Helidon Microprofile Tests TCK Messaging + + + + io.helidon.microprofile.tests + helidon-arquillian + ${project.version} + test + + + io.helidon.microprofile.bundles + helidon-microprofile-3.1 + + + + + io.helidon.microprofile + helidon-microprofile-messaging + 1.3.2-SNAPSHOT + test + + + io.helidon.microprofile.bundles + helidon-microprofile-2.2 + test + + + javax.xml.bind + jaxb-api + test + + + org.jboss.arquillian.junit + arquillian-junit-container + test + + + org.eclipse.microprofile.reactive.messaging + microprofile-reactive-messaging-tck + 1.0 + test + + + org.jboss.arquillian.junit + arquillian-junit-container + + + + + org.slf4j + slf4j-simple + test + + + javax.activation + javax.activation-api + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + false + + + org.eclipse.microprofile.reactive.messaging:microprofile-reactive-messaging-tck + + + + + org.apache.maven.surefire + surefire-junit4 + ${version.plugin.surefire} + + + + + + diff --git a/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml b/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml new file mode 100644 index 00000000000..b7ae45b1456 --- /dev/null +++ b/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml @@ -0,0 +1,29 @@ + + + + + + + target/deployments + + From dad9924cc2c9729c7ff843e9733014baa3207f7e Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Fri, 1 Nov 2019 17:04:44 +0100 Subject: [PATCH 04/66] Extra ugly ReactiveStreamEngine POC with Multi support Signed-off-by: Daniel Kec --- .../io/helidon/common/reactive/Multi.java | 6 + .../common/reactive/MultiFromPublisher.java | 40 +++- .../AbstractConnectableChannelMethod.java | 0 .../messaging}/ChannelRouter.java | 0 .../messaging}/IncomingSubscriber.java | 0 .../messaging}/MessagingCdiExtension.java | 5 - .../messaging}/OutgoingPublisher.java | 9 +- .../messaging}/ScheduledPublisher.java | 0 .../reactive/ConsumableSubscriber.java | 36 ++++ .../reactive/HelidonReactiveStreamEngine.java | 64 ++++++ .../reactive/SimpleCompletionStage.java | 201 ++++++++++++++++++ ...treams.operators.spi.ReactiveStreamsEngine | 20 ++ .../messaging/AbstractCDITest.java | 99 +++++++++ .../messaging/KafkaCdiExtensionTest.java} | 122 +++-------- .../messaging/MessagingCdiExtensionTest.java | 25 +++ .../messaging/beans/InternalChannelsBean.java | 35 +++ .../messaging/beans/KafkaConsumingBean.java} | 37 ++-- .../beans/KafkaProducingConsumingBean.java | 53 +++++ microprofile/tests/tck/tck-messaging/pom.xml | 9 +- 19 files changed, 634 insertions(+), 127 deletions(-) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/AbstractConnectableChannelMethod.java (100%) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/ChannelRouter.java (100%) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/IncomingSubscriber.java (100%) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/MessagingCdiExtension.java (92%) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/OutgoingPublisher.java (83%) rename microprofile/messaging/src/main/java/{io.helidon.microprofile.messaging => io/helidon/microprofile/messaging}/ScheduledPublisher.java (100%) create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java create mode 100644 microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java rename microprofile/messaging/src/test/java/{io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java => io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java} (52%) create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java rename microprofile/messaging/src/test/java/{io.helidon.microprofile.messaging/KafkaConsumingTestBean.java => io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java} (51%) create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java index 836e1f4dff9..b9facec42a7 100644 --- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java +++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java @@ -116,6 +116,12 @@ static Multi just(T... items) { return new MultiFromPublisher<>(new FixedItemsPublisher<>(List.of(items))); } + //TODO: This is just POC, hide it behind org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams + @SafeVarargs + static org.reactivestreams.Publisher justMP(T... items) { + return new MultiFromPublisher<>(new FixedItemsPublisher<>(listOf(items))); + } + /** * Create a {@link Multi} instance that reports the given exception to its subscriber(s). The exception is reported by * invoking {@link Subscriber#onError(java.lang.Throwable)} when {@link Publisher#subscribe(Subscriber)} is called. diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java index 9b6494120d2..38e49320325 100644 --- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java +++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java @@ -15,6 +15,8 @@ */ package io.helidon.common.reactive; +import org.reactivestreams.Subscription; + import java.util.Objects; import java.util.concurrent.Flow; import java.util.concurrent.Flow.Publisher; @@ -25,7 +27,7 @@ * * @param items type */ -final class MultiFromPublisher implements Multi { +final class MultiFromPublisher implements Multi, org.reactivestreams.Publisher { private final Flow.Publisher source; @@ -38,4 +40,40 @@ final class MultiFromPublisher implements Multi { public void subscribe(Subscriber subscriber) { source.subscribe(subscriber); } + + //TODO: This is just POC + @Override + public void subscribe(org.reactivestreams.Subscriber s) { + source.subscribe(new Subscriber() { + @Override + public void onSubscribe(Flow.Subscription subscription) { + s.onSubscribe(new Subscription() { + @Override + public void request(long n) { + subscription.request(n); + } + + @Override + public void cancel() { + subscription.cancel(); + } + }); + } + + @Override + public void onNext(T item) { + s.onNext(item); + } + + @Override + public void onError(Throwable throwable) { + s.onError(throwable); + } + + @Override + public void onComplete() { + s.onComplete(); + } + }); + } } diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java similarity index 100% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/AbstractConnectableChannelMethod.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java similarity index 100% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ChannelRouter.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java similarity index 100% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/IncomingSubscriber.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java similarity index 92% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java index 78835f52132..1e41e705899 100644 --- a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/MessagingCdiExtension.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java @@ -40,13 +40,11 @@ public class MessagingCdiExtension implements Extension { private ChannelRouter channelRouter = new ChannelRouter(); private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, Outgoing.class}) ProcessAnnotatedType pat) { - LOGGER.info("Registering incoming methods"); pat.getAnnotatedType().getMethods() .stream() .filter(m -> m.isAnnotationPresent(Incoming.class)) .forEach(m -> channelRouter.addIncomingMethod(m)); - LOGGER.info("Registering outgoing methods"); pat.getAnnotatedType().getMethods() .stream() .filter(m -> m.isAnnotationPresent(Outgoing.class)) @@ -54,17 +52,14 @@ private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, } public void onProcessBean(@Observes ProcessManagedBean event) { - LOGGER.info("Lookup connectors"); // Lookup connectors Connector annotation = event.getAnnotatedBeanClass().getAnnotation(Connector.class); if (IncomingConnectorFactory.class.isAssignableFrom(event.getBean().getBeanClass()) && null != annotation) { channelRouter.addConnectorFactory(event.getBean()); } - LOGGER.info("Gather references"); // Gather bean references //TODO: Multiple bean references(not singleton) channelRouter.registerBeanReference(event.getBean()); - LOGGER.info("References gathered"); } public void makeConnections(@Observes AfterDeploymentValidation event, BeanManager beanManager) { diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java similarity index 83% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java index 43e200ff74b..0a694dfb22a 100644 --- a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/OutgoingPublisher.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java @@ -3,11 +3,10 @@ import io.helidon.config.Config; import io.helidon.config.ConfigValue; import io.helidon.microprofile.config.MpConfig; -import io.reactivex.Flowable; -import io.reactivex.schedulers.Schedulers; import org.eclipse.microprofile.reactive.messaging.Message; import org.eclipse.microprofile.reactive.messaging.Outgoing; import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory; +import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams; import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder; import org.reactivestreams.Publisher; import org.reactivestreams.Subscriber; @@ -50,7 +49,11 @@ public void connect() { if (incomingSubscribers != null) { for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) { //TODO: get rid of reactivex - ((Flowable)result).observeOn(Schedulers.computation()).subscribe(o -> s.onNext(Message.of(o))); + //((Flowable)result).observeOn(Schedulers.computation()).subscribe(o -> s.onNext(Message.of(o))); + //result.subscribe(new ConsumableSubscriber(m -> s.onNext(Message.of(m)))); + ReactiveStreams.fromPublisher(result).to(s).run(); +// publisherBuilder.buildRs().subscribe(new ConsumableSubscriber(m -> s.onNext(Message.of(m)))); +// publisherBuilder.buildRs(). } } diff --git a/microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java similarity index 100% rename from microprofile/messaging/src/main/java/io.helidon.microprofile.messaging/ScheduledPublisher.java rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java new file mode 100644 index 00000000000..c6bd1d5608e --- /dev/null +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java @@ -0,0 +1,36 @@ +package io.helidon.microprofile.reactive; + +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import java.util.function.Consumer; + +public class ConsumableSubscriber implements Subscriber { + + private Consumer onNext; + + public ConsumableSubscriber(Consumer onNext) { + this.onNext = onNext; + } + + @Override + public void onSubscribe(Subscription s) { + System.out.println(s); + + } + + @Override + public void onNext(T o) { + onNext.accept(o); + } + + @Override + public void onError(Throwable t) { + + } + + @Override + public void onComplete() { + + } +} diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java new file mode 100644 index 00000000000..ab303c0b45b --- /dev/null +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java @@ -0,0 +1,64 @@ +package io.helidon.microprofile.reactive; + +import io.helidon.common.reactive.Collector; +import io.helidon.common.reactive.Multi; +import io.helidon.microprofile.messaging.IncomingSubscriber; +import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.streams.operators.spi.Graph; +import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine; +import org.eclipse.microprofile.reactive.streams.operators.spi.Stage; +import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage; +import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException; +import org.reactivestreams.Processor; +import org.reactivestreams.Publisher; + +import java.util.concurrent.CompletionStage; + +public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine { + @Override + public Publisher buildPublisher(Graph graph) throws UnsupportedStageException { + //TODO: Stages + return (Publisher) ((Stage.PublisherStage) graph.getStages().stream().findFirst().get()).getRsPublisher(); + //return graph.getStages().stream().findFirst().get(). + } + + @Override + public SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException { + return null; + } + + @Override + public Processor buildProcessor(Graph graph) throws UnsupportedStageException { + return null; + } + + @Override + public CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException { + //TODO: Well this is ugly + Multi multi = graph.getStages().stream() + .filter(s -> s instanceof Stage.PublisherStage) + .map(s -> ((Stage.PublisherStage) s).getRsPublisher()) + .filter(p -> p instanceof Multi) + .map(p -> (Multi) p) + .findFirst().get(); + + IncomingSubscriber incomingSubscriber = graph.getStages().stream() + .filter(s -> s instanceof Stage.SubscriberStage) + .map(s -> ((Stage.SubscriberStage) s).getRsSubscriber()) + .map(s -> (IncomingSubscriber) s) + .findFirst().get(); + + return multi.collect(new Collector() { + @Override + public void collect(Object item) { + incomingSubscriber.onNext(Message.of(item)); + } + + @Override + public Object value() { + return null; + } + }).toStage(); + + } +} diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java new file mode 100644 index 00000000000..9dba4aa8e93 --- /dev/null +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java @@ -0,0 +1,201 @@ +package io.helidon.microprofile.reactive; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.Executor; +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Function; + +public class SimpleCompletionStage implements CompletionStage { + @Override + public CompletionStage thenApply(Function fn) { + return null; + } + + @Override + public CompletionStage thenApplyAsync(Function fn) { + return null; + } + + @Override + public CompletionStage thenApplyAsync(Function fn, Executor executor) { + return null; + } + + @Override + public CompletionStage thenAccept(Consumer action) { + return null; + } + + @Override + public CompletionStage thenAcceptAsync(Consumer action) { + return null; + } + + @Override + public CompletionStage thenAcceptAsync(Consumer action, Executor executor) { + return null; + } + + @Override + public CompletionStage thenRun(Runnable action) { + return null; + } + + @Override + public CompletionStage thenRunAsync(Runnable action) { + return null; + } + + @Override + public CompletionStage thenRunAsync(Runnable action, Executor executor) { + return null; + } + + @Override + public CompletionStage thenCombine(CompletionStage other, BiFunction fn) { + return null; + } + + @Override + public CompletionStage thenCombineAsync(CompletionStage other, BiFunction fn) { + return null; + } + + @Override + public CompletionStage thenCombineAsync(CompletionStage other, BiFunction fn, Executor executor) { + return null; + } + + @Override + public CompletionStage thenAcceptBoth(CompletionStage other, BiConsumer action) { + return null; + } + + @Override + public CompletionStage thenAcceptBothAsync(CompletionStage other, BiConsumer action) { + return null; + } + + @Override + public CompletionStage thenAcceptBothAsync(CompletionStage other, BiConsumer action, Executor executor) { + return null; + } + + @Override + public CompletionStage runAfterBoth(CompletionStage other, Runnable action) { + return null; + } + + @Override + public CompletionStage runAfterBothAsync(CompletionStage other, Runnable action) { + return null; + } + + @Override + public CompletionStage runAfterBothAsync(CompletionStage other, Runnable action, Executor executor) { + return null; + } + + @Override + public CompletionStage applyToEither(CompletionStage other, Function fn) { + return null; + } + + @Override + public CompletionStage applyToEitherAsync(CompletionStage other, Function fn) { + return null; + } + + @Override + public CompletionStage applyToEitherAsync(CompletionStage other, Function fn, Executor executor) { + return null; + } + + @Override + public CompletionStage acceptEither(CompletionStage other, Consumer action) { + return null; + } + + @Override + public CompletionStage acceptEitherAsync(CompletionStage other, Consumer action) { + return null; + } + + @Override + public CompletionStage acceptEitherAsync(CompletionStage other, Consumer action, Executor executor) { + return null; + } + + @Override + public CompletionStage runAfterEither(CompletionStage other, Runnable action) { + return null; + } + + @Override + public CompletionStage runAfterEitherAsync(CompletionStage other, Runnable action) { + return null; + } + + @Override + public CompletionStage runAfterEitherAsync(CompletionStage other, Runnable action, Executor executor) { + return null; + } + + @Override + public CompletionStage thenCompose(Function> fn) { + return null; + } + + @Override + public CompletionStage thenComposeAsync(Function> fn) { + return null; + } + + @Override + public CompletionStage thenComposeAsync(Function> fn, Executor executor) { + return null; + } + + @Override + public CompletionStage handle(BiFunction fn) { + return null; + } + + @Override + public CompletionStage handleAsync(BiFunction fn) { + return null; + } + + @Override + public CompletionStage handleAsync(BiFunction fn, Executor executor) { + return null; + } + + @Override + public CompletionStage whenComplete(BiConsumer action) { + return null; + } + + @Override + public CompletionStage whenCompleteAsync(BiConsumer action) { + return null; + } + + @Override + public CompletionStage whenCompleteAsync(BiConsumer action, Executor executor) { + return null; + } + + @Override + public CompletionStage exceptionally(Function fn) { + return null; + } + + @Override + public CompletableFuture toCompletableFuture() { + return null; + } +} diff --git a/microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine b/microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine new file mode 100644 index 00000000000..f6bcc01ee76 --- /dev/null +++ b/microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine @@ -0,0 +1,20 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +io.helidon.microprofile.reactive.HelidonReactiveStreamEngine + +#TODO: Find out why the stream just freeze with smallrye engine +#io.smallrye.reactive.streams.Engine \ No newline at end of file diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java new file mode 100644 index 00000000000..ad885573f6f --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java @@ -0,0 +1,99 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.config.Config; +import io.helidon.config.ConfigSources; +import io.helidon.messaging.kafka.connector.KafkaConnectorFactory; +import io.helidon.microprofile.config.MpConfig; +import io.helidon.microprofile.config.MpConfigProviderResolver; +import io.helidon.microprofile.server.Server; +import org.eclipse.microprofile.reactive.messaging.spi.Connector; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; + +import javax.enterprise.inject.se.SeContainer; +import javax.enterprise.inject.se.SeContainerInitializer; + +import java.io.IOException; +import java.io.InputStream; +import java.lang.annotation.Annotation; +import java.util.HashSet; +import java.util.Properties; +import java.util.Set; +import java.util.function.Consumer; +import java.util.logging.LogManager; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.fail; + +public abstract class AbstractCDITest { + + static { + try (InputStream is = KafkaCdiExtensionTest.class.getResourceAsStream("/logging.properties")) { + LogManager.getLogManager().readConfiguration(is); + } catch (IOException e) { + fail(e); + } + } + + protected static final Connector KAFKA_CONNECTOR_LITERAL = new Connector() { + + @Override + public Class annotationType() { + return Connector.class; + } + + @Override + public String value() { + return KafkaConnectorFactory.CONNECTOR_NAME; + } + }; + + private SeContainer cdiContainer; + + protected void cdiConfig(Properties p){ + //Default config + } + + abstract void cdiBeanClasses(Set> classes); + + @BeforeEach + public void setUp() { + Properties p = new Properties(); + Set> classes = new HashSet<>(); + cdiBeanClasses(classes); + cdiConfig(p); + cdiContainer = startCdiContainer(p, classes); + } + + @AfterEach + public void tearDown() { + if (cdiContainer != null) { + cdiContainer.close(); + } + } + + protected void forEachBean(Class beanType, Annotation annotation, Consumer consumer){ + cdiContainer.select(beanType, annotation).stream().forEach(consumer); + } + + public static SeContainer startCdiContainer(Properties p, Set> beanClasses) { + Config config = Config.builder() + .sources(ConfigSources.create(p)) + .build(); + + final Server.Builder builder = Server.builder(); + assertNotNull(builder); + builder.config(config); + MpConfigProviderResolver.instance() + .registerConfig(MpConfig.builder() + .config(config).build(), + Thread.currentThread().getContextClassLoader()); + final SeContainerInitializer initializer = SeContainerInitializer.newInstance(); + assertThat(initializer, is(notNullValue())); + initializer.addBeanClasses(beanClasses.toArray(new Class[0])); + return initializer.initialize(); + } +} diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java similarity index 52% rename from microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java index fc49e7d5fd7..82db5720d99 100644 --- a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/MessagingCdiExtensionTest.java +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java @@ -21,110 +21,75 @@ import io.helidon.config.ConfigSources; import io.helidon.messaging.kafka.SimpleKafkaProducer; import io.helidon.messaging.kafka.connector.KafkaConnectorFactory; -import io.helidon.microprofile.config.MpConfig; -import io.helidon.microprofile.config.MpConfigProviderResolver; -import io.helidon.microprofile.server.Server; +import io.helidon.microprofile.messaging.beans.KafkaConsumingBean; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.serialization.LongDeserializer; import org.apache.kafka.common.serialization.LongSerializer; import org.apache.kafka.common.serialization.StringDeserializer; import org.apache.kafka.common.serialization.StringSerializer; -import org.eclipse.microprofile.reactive.messaging.spi.Connector; -import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; -import javax.enterprise.inject.se.SeContainer; -import javax.enterprise.inject.se.SeContainerInitializer; - -import java.io.IOException; -import java.io.InputStream; -import java.lang.annotation.Annotation; import java.util.ArrayList; import java.util.List; import java.util.Properties; +import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import java.util.logging.LogManager; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; -class MessagingCdiExtensionTest { +class KafkaCdiExtensionTest extends AbstractCDITest { - private static SeContainer cdiContainer; @RegisterExtension public static final SharedKafkaTestResource kafkaResource = new SharedKafkaTestResource(); public static final String TEST_TOPIC = "graph-done"; public static final String TEST_MESSAGE = "this is first test message"; - - private static final Connector CONNECTOR_LITERAL = new Connector() { - - @Override - public Class annotationType() { - return Connector.class; - } - - @Override - public String value() { - return KafkaConnectorFactory.CONNECTOR_NAME; - } - }; - - @BeforeAll - public synchronized static void startCdiContainer() { - setupLogging(); - Properties p = new Properties(); + @Override + protected void cdiConfig(Properties p) { p.setProperty("mp.messaging.incoming.test-channel.connector", KafkaConnectorFactory.CONNECTOR_NAME); p.setProperty("mp.messaging.incoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString()); p.setProperty("mp.messaging.incoming.test-channel.topic", TEST_TOPIC); p.setProperty("mp.messaging.incoming.test-channel.key.deserializer", LongDeserializer.class.getName()); p.setProperty("mp.messaging.incoming.test-channel.value.deserializer", StringDeserializer.class.getName()); - Config config = Config.builder() - .sources(ConfigSources.create(p)) - .build(); + } + @Override + void cdiBeanClasses(Set> classes) { + classes.add(KafkaConnectorFactory.class); + classes.add(KafkaConsumingBean.class); + } + + @BeforeAll + public static void prepareTopics() { kafkaResource.getKafkaTestUtils().createTopic(TEST_TOPIC, 10, (short) 1); + } - final Server.Builder builder = Server.builder(); - assertNotNull(builder); - builder.config(config); - MpConfigProviderResolver.instance().registerConfig((MpConfig) MpConfig.builder().config(config).build(), Thread.currentThread().getContextClassLoader()); - final SeContainerInitializer initializer = SeContainerInitializer.newInstance(); - assertThat(initializer, is(notNullValue())); - initializer.addBeanClasses(KafkaConnectorFactory.class); - initializer.addBeanClasses(KafkaConsumingTestBean.class); - cdiContainer = initializer.initialize(); - - cdiContainer.select(KafkaConnectorFactory.class).stream().forEach(f -> f.getConsumers().forEach(c -> { + @BeforeEach + @Override + public void setUp() { + super.setUp(); + //Wait till consumers are ready + forEachBean(KafkaConnectorFactory.class, KAFKA_CONNECTOR_LITERAL, b -> b.getConsumers().forEach(c -> { try { c.waitForPartitionAssigment(10, TimeUnit.SECONDS); } catch (InterruptedException | TimeoutException e) { fail(e); } })); - - } - - @AfterAll - public synchronized static void shutDownCdiContainer() { - if (cdiContainer != null) { - cdiContainer.close(); - } } @Test void incomingKafkaTest() throws InterruptedException { + // Producer Properties p = new Properties(); p.setProperty("mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString()); p.setProperty("mp.messaging.outcoming.test-channel.topic", TEST_TOPIC); @@ -135,21 +100,11 @@ void incomingKafkaTest() throws InterruptedException { .sources(ConfigSources.create(p)) .build(); - cdiContainer.select(KafkaConnectorFactory.class, CONNECTOR_LITERAL).stream() - .forEach(f -> f.getConsumers().forEach(c -> { - try { - c.waitForPartitionAssigment(10, TimeUnit.SECONDS); - } catch (InterruptedException | TimeoutException e) { - fail(e); - } - })); - - // Producer SimpleKafkaProducer producer = new SimpleKafkaProducer<>(config.get("mp.messaging.outcoming.test-channel")); - List> producerFutures = new ArrayList<>(3); - producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 1)); - producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 2)); - producerFutures.addAll(producer.produceAsync(TEST_MESSAGE + 3)); + List> producerFutures = new ArrayList<>(KafkaConsumingBean.TEST_DATA.size()); + + //Send all test messages(async send means order is not guaranteed) + KafkaConsumingBean.TEST_DATA.forEach(msg -> producerFutures.addAll(producer.produceAsync(msg))); // Wait for all sent(this is example usage, sent doesn't mean delivered) producerFutures.forEach(f -> { @@ -161,28 +116,9 @@ void incomingKafkaTest() throws InterruptedException { }); // Wait till 3 records are delivered - assertTrue(KafkaConsumingTestBean.testChannelLatch.await(15, TimeUnit.SECONDS) + assertTrue(KafkaConsumingBean.testChannelLatch.await(15, TimeUnit.SECONDS) , "All messages not delivered in time, number of unreceived messages: " - + KafkaConsumingTestBean.testChannelLatch.getCount()); + + KafkaConsumingBean.testChannelLatch.getCount()); producer.close(); } - - @Test - void directOutgoingIncomingTest() throws InterruptedException { - // Wait till 2 messages are delivered - assertTrue(KafkaConsumingTestBean.selfCallLatch.await(15, TimeUnit.SECONDS) - , "All messages not delivered in time, number of unreceived messages: " - + KafkaConsumingTestBean.selfCallLatch.getCount()); - } - - /** - * Configure logging from logging.properties file. - */ - private static void setupLogging() { - try (InputStream is = MessagingCdiExtensionTest.class.getResourceAsStream("/logging.properties")) { - LogManager.getLogManager().readConfiguration(is); - } catch (IOException e) { - fail(e); - } - } } \ No newline at end of file diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java new file mode 100644 index 00000000000..24db80fdeda --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java @@ -0,0 +1,25 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.microprofile.messaging.beans.InternalChannelsBean; +import org.junit.jupiter.api.Test; + +import java.util.Set; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class MessagingCdiExtensionTest extends AbstractCDITest { + + @Override + void cdiBeanClasses(Set> classes) { + classes.add(InternalChannelsBean.class); + } + + @Test + void internalChannelsInSameBeanTest() throws InterruptedException { + // Wait till all messages are delivered + assertTrue(InternalChannelsBean.selfCallLatch.await(10, TimeUnit.SECONDS) + , "All messages not delivered in time, number of unreceived messages: " + + InternalChannelsBean.selfCallLatch.getCount()); + } +} diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java new file mode 100644 index 00000000000..357ef8be3f6 --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java @@ -0,0 +1,35 @@ +package io.helidon.microprofile.messaging.beans; + +import io.helidon.common.reactive.Multi; +import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.Outgoing; +import org.reactivestreams.Publisher; + +import javax.enterprise.context.ApplicationScoped; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CountDownLatch; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +@ApplicationScoped +public class InternalChannelsBean { + + private static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2")); + public static CountDownLatch selfCallLatch = new CountDownLatch(TEST_DATA.size()); + + @Outgoing("self-call-channel") + public Publisher produceMessage() { +// return Flowable.fromIterable(TEST_DATA); + //Nobody needs javarx + return Multi.justMP(TEST_DATA.toArray(new String[0])); + } + + @Incoming("self-call-channel") + public void receiveFromSelfMethod(String msg) { + assertTrue(TEST_DATA.contains(msg), "Unexpected message received"); + selfCallLatch.countDown(); + } +} diff --git a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java similarity index 51% rename from microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java index 06c0f405180..e2d8d694fbb 100644 --- a/microprofile/messaging/src/test/java/io.helidon.microprofile.messaging/KafkaConsumingTestBean.java +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java @@ -14,48 +14,37 @@ * limitations under the License. */ -package io.helidon.microprofile.messaging; +package io.helidon.microprofile.messaging.beans; -import io.reactivex.Flowable; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Message; -import org.eclipse.microprofile.reactive.messaging.Outgoing; -import org.reactivestreams.Publisher; import javax.enterprise.context.ApplicationScoped; import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; import java.util.concurrent.CountDownLatch; +import static org.junit.jupiter.api.Assertions.assertTrue; + @ApplicationScoped -public class KafkaConsumingTestBean { +public class KafkaConsumingBean { - public static int EXPECTED_TOPIC_RECORD_NUMBER = 3; - //Two methods -> two consumers of same topic - public static CountDownLatch testChannelLatch = new CountDownLatch(EXPECTED_TOPIC_RECORD_NUMBER * 2); - public static CountDownLatch selfCallLatch = new CountDownLatch(2); + public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3")); + //Two methods -> two consumers of same topic means twice as much received messages + public static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() * 2); @Incoming("test-channel") - public void receiveMethod1(Message> msg) { + public void receiveMPMessage(Message> msg) { + assertTrue(TEST_DATA.contains(msg.getPayload().value())); testChannelLatch.countDown(); - System.out.println("Received message ->" + msg.getPayload().value()); } @Incoming("test-channel") - public void receiveMethod2(Message> msg) { + public void receiveKafkaConsumerRecord(ConsumerRecord msg) { + assertTrue(TEST_DATA.contains(msg.value())); testChannelLatch.countDown(); - System.out.println("Received message in second consumer ->" + msg.getPayload().value()); - } - - @Outgoing("self-call-channel") - public Publisher produceMessage() { - return Flowable.fromIterable(Arrays.asList("test1", "test2")); - } - - @Incoming("self-call-channel") - public void receiveFromSelfMethod(String msg) { - selfCallLatch.countDown(); - System.out.println("Received message from myself ->" + msg); } } diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java new file mode 100644 index 00000000000..4de9f5e506f --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging.beans; + +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.eclipse.microprofile.reactive.messaging.Incoming; +import org.eclipse.microprofile.reactive.messaging.Outgoing; + +import javax.enterprise.context.ApplicationScoped; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CountDownLatch; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +@ApplicationScoped +//TODO: Implement test +public class KafkaProducingConsumingBean { + + public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3")); + //Two methods -> two consumers of same topic means twice as much received messages + public static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() * 2); + + + @Outgoing("kafka-selfcall-channel") + public void produceToSelf(ConsumerRecord msg) { + assertTrue(TEST_DATA.contains(msg.value())); + testChannelLatch.countDown(); + } + + @Incoming("kafka-selfcall-channel") + public void receiveFromSelf(ConsumerRecord msg) { + assertTrue(TEST_DATA.contains(msg.value())); + testChannelLatch.countDown(); + } + +} diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml index 9b8420a0caf..a8b5bfc1062 100644 --- a/microprofile/tests/tck/tck-messaging/pom.xml +++ b/microprofile/tests/tck/tck-messaging/pom.xml @@ -53,6 +53,12 @@ helidon-microprofile-2.2 test + + + + + + javax.xml.bind jaxb-api @@ -95,7 +101,8 @@ false - org.eclipse.microprofile.reactive.messaging:microprofile-reactive-messaging-tck + org.eclipse.microprofile.reactive.messaging:microprofile-reactive-messaging-tck + From 4a1dac46e23b26323ef9fe8ef9fee81e7ca3f455 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Tue, 5 Nov 2019 22:32:19 +0100 Subject: [PATCH 05/66] Trivial Helidon engine implementation with fist few tck tests passing Signed-off-by: Daniel Kec --- .../io/helidon/common/reactive/Multi.java | 5 + microprofile/messaging/pom.xml | 21 +- .../AbstractConnectableChannelMethod.java | 9 + .../messaging/IncomingSubscriber.java | 29 ++- .../messaging/OutgoingPublisher.java | 10 +- .../messaging/ScheduledPublisher.java | 11 - .../reactive/HelidonReactiveStreamEngine.java | 64 ------ .../reactive/SimpleCompletionStage.java | 201 ------------------ .../messaging/ReactiveEngineTest.java | 77 +++++++ .../helidon/microprofile/messaging/Test.java | 14 ++ microprofile/reactive-bridge/pom.xml | 45 ++++ .../reactive/ConsumableSubscriber.java | 0 .../reactive/HelidonReactiveStreamEngine.java | 65 ++++++ .../reactive/MultiStagesCollector.java | 135 ++++++++++++ ...e.streams.operators.ReactiveStreamsFactory | 17 ++ ...treams.operators.spi.ReactiveStreamsEngine | 5 +- microprofile/tests/tck/tck-messaging/pom.xml | 79 +++---- .../tck/HelidonMessagingExtender.java | 19 ++ ...ile.reactive.messaging.tck.ArchiveExtender | 1 + ...e.streams.operators.ReactiveStreamsFactory | 17 ++ .../src/test/resources/arquillian.xml | 3 +- 21 files changed, 491 insertions(+), 336 deletions(-) delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java create mode 100644 microprofile/reactive-bridge/pom.xml rename microprofile/{messaging => reactive-bridge}/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java (100%) create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java create mode 100644 microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory rename microprofile/{messaging => reactive-bridge}/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine (79%) create mode 100644 microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java create mode 100644 microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender create mode 100644 microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java index b9facec42a7..6e1cbb6a6c4 100644 --- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java +++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java @@ -122,6 +122,11 @@ static org.reactivestreams.Publisher justMP(T... items) { return new MultiFromPublisher<>(new FixedItemsPublisher<>(listOf(items))); } + //TODO: This is just POC, hide it behind org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams + static org.reactivestreams.Publisher justMP(Collection items) { + return new MultiFromPublisher<>(new FixedItemsPublisher<>(items)); + } + /** * Create a {@link Multi} instance that reports the given exception to its subscriber(s). The exception is reported by * invoking {@link Subscriber#onError(java.lang.Throwable)} when {@link Publisher#subscribe(Subscriber)} is called. diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml index bebe8370770..81c0a7b5512 100644 --- a/microprofile/messaging/pom.xml +++ b/microprofile/messaging/pom.xml @@ -65,6 +65,11 @@ io.helidon.microprofile.server helidon-microprofile-server + + io.helidon.microprofile + helidon-microprofile-reactive-bridge + 1.3.2-SNAPSHOT + org.jboss.weld.se weld-se-core @@ -89,11 +94,17 @@ internal-test-libs test - - io.reactivex.rxjava2 - rxjava - - + + + + + + + + + + + org.jboss.weld weld-junit5 diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java index d99ee93e9c2..d708950df0b 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java @@ -5,6 +5,7 @@ import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.BeanManager; +import javax.enterprise.inject.spi.DeploymentException; import java.lang.reflect.Method; @@ -23,6 +24,14 @@ public AbstractConnectableChannelMethod(String channelName, Method method, Chann this.router = router; this.method = method; this.channelName = channelName; + validate(); + } + + private void validate() { + if (channelName == null || channelName.trim().isEmpty()) { + throw new DeploymentException("Missing channel name in annotation @Incoming/@Outgoing on method " + + method.toString()); + } } protected abstract void connect(); diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java index ed930696820..2007a31d9a0 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java @@ -37,7 +37,7 @@ * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming} * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method */ -public class IncomingSubscriber extends AbstractConnectableChannelMethod implements Subscriber> { +public class IncomingSubscriber extends AbstractConnectableChannelMethod implements Subscriber { private static final Logger LOGGER = Logger.getLogger(IncomingSubscriber.class.getName()); @@ -52,8 +52,10 @@ protected void connect() { Config channelConfig = config.get("mp.messaging.incoming").get(channelName); ConfigValue connectorName = channelConfig.get("connector").asString(); if (connectorName.isPresent()) { - publisherBuilder = ((IncomingConnectorFactory) getBeanInstance(getRouter() - .getIncomingConnectorFactory(connectorName.get()), beanManager)) + publisherBuilder = + ((IncomingConnectorFactory) getBeanInstance( + getRouter().getIncomingConnectorFactory(connectorName.get()), + beanManager)) .getPublisherBuilder(MpConfig.builder().config(channelConfig).build()); //TODO: iterate over multiple publishers @@ -68,12 +70,23 @@ public PublisherBuilder> getPublisherBuilder() { } @Override - public void onNext(Message message) { + public void onNext(Object message) { try { final Object paramValue; Class paramType = this.method.getParameterTypes()[0]; - if (paramType != Message.class) { - paramValue = paramType.cast(message.getPayload()); + + if (paramType != Message.class && !(message instanceof Message)) { + paramValue = paramType.cast(message); + + } else if (paramType == Message.class && message instanceof Message) { + paramValue = paramType.cast(message); + + } else if (paramType != Message.class && message instanceof Message) { + paramValue = paramType.cast(((Message) message).getPayload()); + + } else if (paramType == Message.class && !(message instanceof Message)) { + paramValue = paramType.cast(Message.of(message)); + } else { paramValue = message; } @@ -93,11 +106,13 @@ public void onNext(Message message) { @Override public void onError(Throwable t) { //TODO: Error propagation + throw new RuntimeException(t); } @Override public void onSubscribe(Subscription s) { - System.out.println(s); + //TODO: this would be a problem with infinite streams + s.request(Long.MAX_VALUE); } @Override diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java index 0a694dfb22a..e9ff0631421 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java @@ -48,12 +48,10 @@ public void connect() { List incomingSubscribers = getRouter().getIncomingSubscribers(getChannelName()); if (incomingSubscribers != null) { for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) { - //TODO: get rid of reactivex - //((Flowable)result).observeOn(Schedulers.computation()).subscribe(o -> s.onNext(Message.of(o))); - //result.subscribe(new ConsumableSubscriber(m -> s.onNext(Message.of(m)))); - ReactiveStreams.fromPublisher(result).to(s).run(); -// publisherBuilder.buildRs().subscribe(new ConsumableSubscriber(m -> s.onNext(Message.of(m)))); -// publisherBuilder.buildRs(). + ReactiveStreams + .fromPublisher(result) + .to(ReactiveStreams.fromSubscriber(s)) + .run(); } } diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java deleted file mode 100644 index d7c26b3bec8..00000000000 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ScheduledPublisher.java +++ /dev/null @@ -1,11 +0,0 @@ -package io.helidon.microprofile.messaging; - -import org.reactivestreams.Publisher; -import org.reactivestreams.Subscriber; - -public class ScheduledPublisher implements Publisher { - @Override - public void subscribe(Subscriber s) { - - } -} diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java deleted file mode 100644 index ab303c0b45b..00000000000 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java +++ /dev/null @@ -1,64 +0,0 @@ -package io.helidon.microprofile.reactive; - -import io.helidon.common.reactive.Collector; -import io.helidon.common.reactive.Multi; -import io.helidon.microprofile.messaging.IncomingSubscriber; -import org.eclipse.microprofile.reactive.messaging.Message; -import org.eclipse.microprofile.reactive.streams.operators.spi.Graph; -import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine; -import org.eclipse.microprofile.reactive.streams.operators.spi.Stage; -import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage; -import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException; -import org.reactivestreams.Processor; -import org.reactivestreams.Publisher; - -import java.util.concurrent.CompletionStage; - -public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine { - @Override - public Publisher buildPublisher(Graph graph) throws UnsupportedStageException { - //TODO: Stages - return (Publisher) ((Stage.PublisherStage) graph.getStages().stream().findFirst().get()).getRsPublisher(); - //return graph.getStages().stream().findFirst().get(). - } - - @Override - public SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException { - return null; - } - - @Override - public Processor buildProcessor(Graph graph) throws UnsupportedStageException { - return null; - } - - @Override - public CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException { - //TODO: Well this is ugly - Multi multi = graph.getStages().stream() - .filter(s -> s instanceof Stage.PublisherStage) - .map(s -> ((Stage.PublisherStage) s).getRsPublisher()) - .filter(p -> p instanceof Multi) - .map(p -> (Multi) p) - .findFirst().get(); - - IncomingSubscriber incomingSubscriber = graph.getStages().stream() - .filter(s -> s instanceof Stage.SubscriberStage) - .map(s -> ((Stage.SubscriberStage) s).getRsSubscriber()) - .map(s -> (IncomingSubscriber) s) - .findFirst().get(); - - return multi.collect(new Collector() { - @Override - public void collect(Object item) { - incomingSubscriber.onNext(Message.of(item)); - } - - @Override - public Object value() { - return null; - } - }).toStage(); - - } -} diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java deleted file mode 100644 index 9dba4aa8e93..00000000000 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/SimpleCompletionStage.java +++ /dev/null @@ -1,201 +0,0 @@ -package io.helidon.microprofile.reactive; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.Executor; -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.Consumer; -import java.util.function.Function; - -public class SimpleCompletionStage implements CompletionStage { - @Override - public CompletionStage thenApply(Function fn) { - return null; - } - - @Override - public CompletionStage thenApplyAsync(Function fn) { - return null; - } - - @Override - public CompletionStage thenApplyAsync(Function fn, Executor executor) { - return null; - } - - @Override - public CompletionStage thenAccept(Consumer action) { - return null; - } - - @Override - public CompletionStage thenAcceptAsync(Consumer action) { - return null; - } - - @Override - public CompletionStage thenAcceptAsync(Consumer action, Executor executor) { - return null; - } - - @Override - public CompletionStage thenRun(Runnable action) { - return null; - } - - @Override - public CompletionStage thenRunAsync(Runnable action) { - return null; - } - - @Override - public CompletionStage thenRunAsync(Runnable action, Executor executor) { - return null; - } - - @Override - public CompletionStage thenCombine(CompletionStage other, BiFunction fn) { - return null; - } - - @Override - public CompletionStage thenCombineAsync(CompletionStage other, BiFunction fn) { - return null; - } - - @Override - public CompletionStage thenCombineAsync(CompletionStage other, BiFunction fn, Executor executor) { - return null; - } - - @Override - public CompletionStage thenAcceptBoth(CompletionStage other, BiConsumer action) { - return null; - } - - @Override - public CompletionStage thenAcceptBothAsync(CompletionStage other, BiConsumer action) { - return null; - } - - @Override - public CompletionStage thenAcceptBothAsync(CompletionStage other, BiConsumer action, Executor executor) { - return null; - } - - @Override - public CompletionStage runAfterBoth(CompletionStage other, Runnable action) { - return null; - } - - @Override - public CompletionStage runAfterBothAsync(CompletionStage other, Runnable action) { - return null; - } - - @Override - public CompletionStage runAfterBothAsync(CompletionStage other, Runnable action, Executor executor) { - return null; - } - - @Override - public CompletionStage applyToEither(CompletionStage other, Function fn) { - return null; - } - - @Override - public CompletionStage applyToEitherAsync(CompletionStage other, Function fn) { - return null; - } - - @Override - public CompletionStage applyToEitherAsync(CompletionStage other, Function fn, Executor executor) { - return null; - } - - @Override - public CompletionStage acceptEither(CompletionStage other, Consumer action) { - return null; - } - - @Override - public CompletionStage acceptEitherAsync(CompletionStage other, Consumer action) { - return null; - } - - @Override - public CompletionStage acceptEitherAsync(CompletionStage other, Consumer action, Executor executor) { - return null; - } - - @Override - public CompletionStage runAfterEither(CompletionStage other, Runnable action) { - return null; - } - - @Override - public CompletionStage runAfterEitherAsync(CompletionStage other, Runnable action) { - return null; - } - - @Override - public CompletionStage runAfterEitherAsync(CompletionStage other, Runnable action, Executor executor) { - return null; - } - - @Override - public CompletionStage thenCompose(Function> fn) { - return null; - } - - @Override - public CompletionStage thenComposeAsync(Function> fn) { - return null; - } - - @Override - public CompletionStage thenComposeAsync(Function> fn, Executor executor) { - return null; - } - - @Override - public CompletionStage handle(BiFunction fn) { - return null; - } - - @Override - public CompletionStage handleAsync(BiFunction fn) { - return null; - } - - @Override - public CompletionStage handleAsync(BiFunction fn, Executor executor) { - return null; - } - - @Override - public CompletionStage whenComplete(BiConsumer action) { - return null; - } - - @Override - public CompletionStage whenCompleteAsync(BiConsumer action) { - return null; - } - - @Override - public CompletionStage whenCompleteAsync(BiConsumer action, Executor executor) { - return null; - } - - @Override - public CompletionStage exceptionally(Function fn) { - return null; - } - - @Override - public CompletableFuture toCompletableFuture() { - return null; - } -} diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java new file mode 100644 index 00000000000..70f9df9c8e9 --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java @@ -0,0 +1,77 @@ +package io.helidon.microprofile.messaging; + +import io.helidon.common.reactive.microprofile.HelidonReactiveStreamEngine; +import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams; +import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine; +import org.junit.jupiter.api.Test; +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +public class ReactiveEngineTest { + + @Test + void testSmallRye() { +// testEngine(new io.smallrye.reactive.streams.Engine()); + } + + @Test + void testTestHelidon() { + testEngine(new HelidonReactiveStreamEngine()); + } + + private void testEngine(ReactiveStreamsEngine engine) { + Publisher publisher = ReactiveStreams.of("test1", "test2", "test3") + .buildRs(engine); + LatchSubscriber subscriber = new LatchSubscriber<>(); + + ReactiveStreams + .fromPublisher(publisher) + .to(ReactiveStreams.fromSubscriber(subscriber)) + .run(engine) + .toCompletableFuture(); + subscriber.assertNextCalled(); + } + + private class LatchSubscriber extends CountDownLatch implements Subscriber { + + public LatchSubscriber() { + super(1); + } + + + @Override + public void onSubscribe(Subscription s) { + + } + + @Override + public void onNext(T t) { + countDown(); + } + + @Override + public void onError(Throwable t) { + + } + + @Override + public void onComplete() { + + } + + public void assertNextCalled() { + try { + assertTrue(this.await(2, TimeUnit.SECONDS)); + } catch (InterruptedException e) { + fail(e); + } + } + } +} diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java new file mode 100644 index 00000000000..d78e72069a3 --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java @@ -0,0 +1,14 @@ +package io.helidon.microprofile.messaging; + +import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams; + +public class Test { + public static void main(String[] args) { + // Create a stream of words + ReactiveStreams.of("hello", "from", "smallrye", "reactive", "stream", "operators") + .map(String::toUpperCase) // Transform the words + .filter(s -> s.length() > 4) // Filter items + .forEach(word -> System.out.println(">> " + word)) // Terminal operation + .run(); // Run it (create the streams, subscribe to it...) + } +} diff --git a/microprofile/reactive-bridge/pom.xml b/microprofile/reactive-bridge/pom.xml new file mode 100644 index 00000000000..6e237d54963 --- /dev/null +++ b/microprofile/reactive-bridge/pom.xml @@ -0,0 +1,45 @@ + + + + + 4.0.0 + + + io.helidon.microprofile + helidon-microprofile-project + 1.3.2-SNAPSHOT + + + io.helidon.microprofile + helidon-microprofile-reactive-bridge + Helidon Reactive Bridge + + + + io.helidon.common + helidon-common-reactive + + + org.eclipse.microprofile.reactive-streams-operators + microprofile-reactive-streams-operators-api + 1.0.1 + + + \ No newline at end of file diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java similarity index 100% rename from microprofile/messaging/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java rename to microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java new file mode 100644 index 00000000000..7ccee8b2da8 --- /dev/null +++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java @@ -0,0 +1,65 @@ +package io.helidon.microprofile.reactive; + +import io.helidon.common.reactive.Multi; +import org.eclipse.microprofile.reactive.streams.operators.spi.Graph; +import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine; +import org.eclipse.microprofile.reactive.streams.operators.spi.Stage; +import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage; +import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException; +import org.reactivestreams.Processor; +import org.reactivestreams.Publisher; + +import java.util.Collection; +import java.util.concurrent.CompletionStage; +import java.util.logging.Logger; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine { + + private static final Logger LOGGER = Logger.getLogger(HelidonReactiveStreamEngine.class.getName()); + + @Override + public Publisher buildPublisher(Graph graph) throws UnsupportedStageException { + Collection stages = graph.getStages(); + if (stages.size() != 1) { + //TODO: Support more than one stage + throw new RuntimeException("Exactly one stage is supported for now"); + } + + Stage firstStage = stages.iterator().next(); + if (firstStage instanceof Stage.PublisherStage) { + Stage.PublisherStage publisherStage = (Stage.PublisherStage) firstStage; + return (Publisher) publisherStage.getRsPublisher(); + } else if (firstStage instanceof Stage.Of) { + //Collection + Stage.Of stageOf = (Stage.Of) firstStage; + return Multi.justMP(StreamSupport.stream(stageOf.getElements().spliterator(), false) + .map(e -> (T) e) + .collect(Collectors.toList())); + } else { + throw new UnsupportedStageException(firstStage); + } + } + + @Override + public SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException { + return null; + } + + @Override + public Processor buildProcessor(Graph graph) throws UnsupportedStageException { + return null; + } + + @Override + public CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException { + MultiStagesCollector multiStagesCollector = new MultiStagesCollector(); + graph.getStages().stream().collect(multiStagesCollector); + CompletionStage completionStage = (CompletionStage) multiStagesCollector.toCompletableStage(); + completionStage.exceptionally(t -> {throw new RuntimeException(t);}); + return completionStage; + } +} + + diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java new file mode 100644 index 00000000000..bc69ebaba31 --- /dev/null +++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java @@ -0,0 +1,135 @@ +package io.helidon.microprofile.reactive; + +import io.helidon.common.mapper.Mapper; +import io.helidon.common.reactive.Multi; +import io.helidon.common.reactive.Single; +import io.helidon.common.reactive.valve.Valves; +import org.eclipse.microprofile.reactive.streams.operators.spi.Stage; +import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException; +import org.reactivestreams.Subscriber; + +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CompletionStage; +import java.util.function.BiConsumer; +import java.util.function.BinaryOperator; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.function.Supplier; +import java.util.stream.Collector; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +public class MultiStagesCollector implements Collector, CompletionStage> { + + private Multi multi = null; + private Single single = null; + + @Override + public Supplier> supplier() { + return () -> multi != null ? multi : Multi.empty(); + } + + @Override + public BiConsumer, Stage> accumulator() { + //MP Stages to Helidon multi streams mapping + return (m, stage) -> { + + // Create stream + if (stage instanceof Stage.PublisherStage) { + Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage; + if (publisherStage.getRsPublisher() instanceof Multi) { + multi = (Multi) ((Stage.PublisherStage) stage).getRsPublisher(); + } else { + + throw new UnsupportedStageException(stage); + } + } else if (stage instanceof Stage.Of) { + //Collection + Stage.Of stageOf = (Stage.Of) stage; + multi = Multi.just(StreamSupport.stream(stageOf.getElements().spliterator(), false) + .collect(Collectors.toList())); + + } else if (stage instanceof Stage.Map) { + // Transform stream + Stage.Map stageMap = (Stage.Map) stage; + multi = multi.map(new Mapper() { + @Override + public Object map(Object t) { + Function mapper = (Function) stageMap.getMapper(); + return mapper.apply(t); + } + }); + + } else if (stage instanceof Stage.Filter) { + //Filter stream + Stage.Filter stageFilter = (Stage.Filter) stage; + Predicate predicate = (Predicate) stageFilter.getPredicate(); + //TODO: Ask Tomas this doesn't seems right + multi = Multi.from(Valves.from(multi).filter(predicate).toPublisher()); + + } else if (stage instanceof Stage.SubscriberStage) { + //Subscribe to stream + Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage; + Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber(); + single = multi.collect(new io.helidon.common.reactive.Collector() { + @Override + public void collect(Object item) { + subscriber.onNext(item); + } + + @Override + public Object value() { + return null; + } + }); + + } else if (stage instanceof Stage.Collect) { + //Collect stream + Stage.Collect stageFilter = (Stage.Collect) stage; + Collector collector = (Collector) stageFilter.getCollector(); + single = multi.collect(new io.helidon.common.reactive.Collector() { + @Override + public void collect(Object item) { + collector.finisher().apply(item); + } + + @Override + public Object value() { + return null; + } + }); + } else { + throw new UnsupportedStageException(stage); + } + }; + } + + @Override + public BinaryOperator> combiner() { + return (a, b) -> null; + } + + @Override + public Function, CompletionStage> finisher() { + return t -> toCompletableStage(); + } + + @Override + public Set characteristics() { + return new HashSet<>(Collections.singletonList(Characteristics.IDENTITY_FINISH)); + } + + public Multi getMulti() { + return this.multi; + } + + public Single getSingle() { + return this.single; + } + + public CompletionStage toCompletableStage() { + return this.single != null ? single.toStage() : null; + } +} diff --git a/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory b/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory new file mode 100644 index 00000000000..8e4c3a64b7e --- /dev/null +++ b/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory @@ -0,0 +1,17 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +org.eclipse.microprofile.reactive.streams.operators.core.ReactiveStreamsFactoryImpl \ No newline at end of file diff --git a/microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine b/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine similarity index 79% rename from microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine rename to microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine index f6bcc01ee76..f6dfaa769a0 100644 --- a/microprofile/messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine +++ b/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine @@ -14,7 +14,4 @@ # limitations under the License. # -io.helidon.microprofile.reactive.HelidonReactiveStreamEngine - -#TODO: Find out why the stream just freeze with smallrye engine -#io.smallrye.reactive.streams.Engine \ No newline at end of file +io.helidon.microprofile.reactive.HelidonReactiveStreamEngine \ No newline at end of file diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml index a8b5bfc1062..a73997ea3ae 100644 --- a/microprofile/tests/tck/tck-messaging/pom.xml +++ b/microprofile/tests/tck/tck-messaging/pom.xml @@ -23,13 +23,29 @@ 4.0.0 io.helidon.microprofile.tests - tck-project + tests-project 1.3.2-SNAPSHOT tck-messaging Helidon Microprofile Tests TCK Messaging + + org.eclipse.microprofile.reactive.messaging + microprofile-reactive-messaging-tck + 1.0 + + + rxjava + io.reactivex.rxjava2 + + + + + io.reactivex.rxjava2 + rxjava + 2.2.13 + io.helidon.microprofile.tests helidon-arquillian @@ -42,55 +58,44 @@ - - io.helidon.microprofile - helidon-microprofile-messaging - 1.3.2-SNAPSHOT - test - - - io.helidon.microprofile.bundles - helidon-microprofile-2.2 - test - - - - - - - - - javax.xml.bind - jaxb-api - test - org.jboss.arquillian.junit arquillian-junit-container test - org.eclipse.microprofile.reactive.messaging - microprofile-reactive-messaging-tck - 1.0 - test + io.helidon.microprofile + helidon-microprofile-messaging + 1.3.2-SNAPSHOT + - org.jboss.arquillian.junit - arquillian-junit-container + io.helidon.microprofile + helidon-microprofile-reactive-bridge + + + + + - org.slf4j - slf4j-simple - test - - - javax.activation - javax.activation-api - test + io.smallrye.reactive + smallrye-reactive-streams-operators + 1.0.10 + + + rxjava + io.reactivex.rxjava2 + + + + + + + diff --git a/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java b/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java new file mode 100644 index 00000000000..fc67531f19b --- /dev/null +++ b/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java @@ -0,0 +1,19 @@ +package io.smallrye.reactive.messaging.tck; + +import javax.enterprise.inject.spi.Extension; + +import io.helidon.microprofile.messaging.MessagingCdiExtension; +import org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender; +import org.jboss.shrinkwrap.api.asset.EmptyAsset; +import org.jboss.shrinkwrap.api.spec.JavaArchive; + + +public class HelidonMessagingExtender implements ArchiveExtender { + @Override + public void extend(JavaArchive archive) { + archive + .addPackages(true, MessagingCdiExtension.class.getPackage()) + .addAsServiceProvider(Extension.class, MessagingCdiExtension.class) + .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml"); + } +} diff --git a/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender b/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender new file mode 100644 index 00000000000..744b174b823 --- /dev/null +++ b/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender @@ -0,0 +1 @@ +io.smallrye.reactive.messaging.tck.HelidonMessagingExtender diff --git a/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory b/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory new file mode 100644 index 00000000000..8e4c3a64b7e --- /dev/null +++ b/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory @@ -0,0 +1,17 @@ +# +# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. +# +# 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. +# + +org.eclipse.microprofile.reactive.streams.operators.core.ReactiveStreamsFactoryImpl \ No newline at end of file diff --git a/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml b/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml index b7ae45b1456..45075f08eb0 100644 --- a/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml +++ b/microprofile/tests/tck/tck-messaging/src/test/resources/arquillian.xml @@ -25,5 +25,6 @@ target/deployments - + -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y + From e8d86e41bdf63529a1c77abae57852abf5f01254 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Wed, 6 Nov 2019 16:32:13 +0100 Subject: [PATCH 06/66] More tck bending Signed-off-by: Daniel Kec --- .../kafka/KafkaConfigProperties.java | 8 +- .../AbstractConnectableChannelMethod.java | 31 +++-- .../messaging/AdHocConfigBuilder.java | 63 +++++++++++ .../microprofile/messaging/ChannelRouter.java | 24 +++- .../messaging/IncomingSubscriber.java | 45 ++++++-- .../messaging/MessagingCdiExtension.java | 4 +- .../messaging/OutgoingPublisher.java | 92 ++++++++++----- .../messaging/AdHocConfigBuilderTest.java | 106 ++++++++++++++++++ .../reactive/MultiStagesCollector.java | 18 ++- 9 files changed, 341 insertions(+), 50 deletions(-) create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java index 5ee4bbc6bff..8504e9e1937 100644 --- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java +++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java @@ -17,6 +17,7 @@ package io.helidon.messaging.kafka; import io.helidon.config.Config; +import io.helidon.config.ConfigValue; import java.util.Arrays; import java.util.List; @@ -95,8 +96,11 @@ private void addProperty(Config c) { if (c.hasValue()) { value = c.asString().get(); } else { - value = c.traverse(v -> v.type() == Config.Type.VALUE).findFirst() - .get().asString().get(); + value = c.traverse(v -> v.type() == Config.Type.VALUE) + .map(Config::asString) + .map(v -> v.orElse("")) + .findFirst() + .orElse(""); } this.setProperty(key, value); } diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java index d708950df0b..315138464e8 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; import io.helidon.config.Config; @@ -27,20 +43,14 @@ public AbstractConnectableChannelMethod(String channelName, Method method, Chann validate(); } - private void validate() { - if (channelName == null || channelName.trim().isEmpty()) { - throw new DeploymentException("Missing channel name in annotation @Incoming/@Outgoing on method " - + method.toString()); - } - } + abstract void validate(); protected abstract void connect(); - public void connect(BeanManager beanManager, Config config) { + public void init(BeanManager beanManager, Config config) { this.beanInstance = getBeanInstance(bean, beanManager); this.beanManager = beanManager; this.config = config; - connect(); } public void setDeclaringBean(Bean bean) { @@ -60,7 +70,10 @@ protected Object getBeanInstance(Bean bean, BeanManager beanManager) { Object instance = context.get(bean); if (instance == null) { CreationalContext creationalContext = beanManager.createCreationalContext(bean); - return beanManager.getReference(bean, bean.getBeanClass(), creationalContext); + instance = beanManager.getReference(bean, bean.getBeanClass(), creationalContext); + } + if (instance == null) { + throw new DeploymentException("Instance of bean " + bean.getName() + " not found"); } return instance; } diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java new file mode 100644 index 00000000000..899bdeeb86d --- /dev/null +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import io.helidon.common.CollectionsHelper; +import io.helidon.config.Config; +import io.helidon.config.ConfigSources; +import io.helidon.microprofile.config.MpConfig; + +import java.util.Properties; + +public class AdHocConfigBuilder { + private Config config; + private Properties properties = new Properties(); + + private AdHocConfigBuilder(Config config) { + this.config = config.detach(); + } + + public static AdHocConfigBuilder from(Config config) { + return new AdHocConfigBuilder(config); + } + + public AdHocConfigBuilder put(String key, String value) { + properties.setProperty(key, value); + return this; + } + + public AdHocConfigBuilder putAll(Config configToPut) { + properties.putAll(configToPut.detach().asMap().orElse(CollectionsHelper.mapOf())); + return this; + } + + public org.eclipse.microprofile.config.Config build() { + //TODO: There has to be some better way +// return MpConfig.builder().config(((MpConfig) mpConfigBuilder +// .config(Config.builder().sources(ConfigSources.create(config), ConfigSources.create(properties)).build()) +// .build()).helidonConfig().get(currentContext)).build(); +// + Config newConfig = Config.builder(ConfigSources.create(properties), ConfigSources.create(config)) + .disableEnvironmentVariablesSource() + .disableSystemPropertiesSource() + .build(); + + return MpConfig.builder() + .config(newConfig) + .build(); + } +} diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java index 4717fe9abe7..462f37f59da 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; import io.helidon.config.Config; @@ -31,7 +47,10 @@ public void registerBeanReference(Bean bean) { public void connect(BeanManager beanManager) { Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig(); - connectableBeanMethods.forEach(m -> m.connect(beanManager, config)); + //Needs to be initialized before connecting, + // fast publishers would call onNext before all bean references are resolved + connectableBeanMethods.forEach(m -> m.init(beanManager, config)); + connectableBeanMethods.forEach(AbstractConnectableChannelMethod::connect); } void addIncomingMethod(AnnotatedMethod m) { @@ -53,7 +72,8 @@ void addConnectorFactory(Bean bean) { Connector annotation = beanType.getAnnotation(Connector.class); if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { incomingConnectorFactoryMap.put(annotation.value(), bean); - } else if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { + } + if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) { outgoingConnectorFactoryMap.put(annotation.value(), bean); } } diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java index 2007a31d9a0..0f74be5ec43 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java @@ -20,15 +20,16 @@ import io.helidon.common.context.Contexts; import io.helidon.config.Config; import io.helidon.config.ConfigValue; -import io.helidon.microprofile.config.MpConfig; import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory; import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.DeploymentException; import java.util.UUID; import java.util.logging.Logger; @@ -42,23 +43,42 @@ public class IncomingSubscriber extends AbstractConnectableChannelMethod impleme private static final Logger LOGGER = Logger.getLogger(IncomingSubscriber.class.getName()); private PublisherBuilder> publisherBuilder; + private Subscription subscription; + private Long chunkSize = 5L; + private Long chunkPosition = 0L; public IncomingSubscriber(AnnotatedMethod method, ChannelRouter router) { super(method.getAnnotation(Incoming.class).value(), method.getJavaMember(), router); } + void validate() { + if (channelName == null || channelName.trim().isEmpty()) { + throw new DeploymentException("Missing channel name in annotation @Incoming on method " + + method.toString()); + } + } + @Override protected void connect() { Config channelConfig = config.get("mp.messaging.incoming").get(channelName); ConfigValue connectorName = channelConfig.get("connector").asString(); if (connectorName.isPresent()) { + Config connectorConfig = config.get("mp.messaging.connector") + .get(connectorName.get()); + org.eclipse.microprofile.config.Config augmentedConfig = + AdHocConfigBuilder + .from(channelConfig) + //It seams useless but its required by the spec + .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, channelName) + .putAll(connectorConfig) + .build(); publisherBuilder = ((IncomingConnectorFactory) getBeanInstance( getRouter().getIncomingConnectorFactory(connectorName.get()), beanManager)) - .getPublisherBuilder(MpConfig.builder().config(channelConfig).build()); + .getPublisherBuilder(augmentedConfig); - //TODO: iterate over multiple publishers + //TODO: iterate over multiple publishers / does spec even support multiple publishers? publisherBuilder.buildRs().subscribe(this); LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", channelName, connectorName.get(), method.toString())); } @@ -69,6 +89,14 @@ public PublisherBuilder> getPublisherBuilder() { return publisherBuilder; } + private void incrementAndCheckChunkPosition() { + chunkPosition++; + if (chunkPosition >= chunkSize) { + chunkPosition = 0L; + subscription.request(chunkSize); + } + } + @Override public void onNext(Object message) { try { @@ -97,22 +125,25 @@ public void onNext(Object message) { .parent(parentContext) .id(parentContext.id() + ":message-" + UUID.randomUUID().toString()) .build(); - Contexts.runInContext(context, () -> method.invoke(beanInstance, paramValue)); + Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, paramValue)); + incrementAndCheckChunkPosition(); } catch (Exception e) { + //Notify publisher to stop sending + subscription.cancel(); throw new RuntimeException(e); } } @Override public void onError(Throwable t) { - //TODO: Error propagation throw new RuntimeException(t); } @Override public void onSubscribe(Subscription s) { - //TODO: this would be a problem with infinite streams - s.request(Long.MAX_VALUE); + subscription = s; + //First chunk request + subscription.request(chunkSize); } @Override diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java index 1e41e705899..c046669a0a6 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java @@ -19,7 +19,6 @@ import org.eclipse.microprofile.reactive.messaging.Incoming; import org.eclipse.microprofile.reactive.messaging.Outgoing; import org.eclipse.microprofile.reactive.messaging.spi.Connector; -import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory; import javax.enterprise.event.Observes; import javax.enterprise.inject.spi.AfterDeploymentValidation; @@ -53,8 +52,7 @@ private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, public void onProcessBean(@Observes ProcessManagedBean event) { // Lookup connectors - Connector annotation = event.getAnnotatedBeanClass().getAnnotation(Connector.class); - if (IncomingConnectorFactory.class.isAssignableFrom(event.getBean().getBeanClass()) && null != annotation) { + if (null != event.getAnnotatedBeanClass().getAnnotation(Connector.class)) { channelRouter.addConnectorFactory(event.getBean()); } // Gather bean references diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java index e9ff0631421..f471a95bb2b 100644 --- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; import io.helidon.config.Config; @@ -6,12 +22,14 @@ import org.eclipse.microprofile.reactive.messaging.Message; import org.eclipse.microprofile.reactive.messaging.Outgoing; import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory; +import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams; import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder; import org.reactivestreams.Publisher; import org.reactivestreams.Subscriber; import javax.enterprise.inject.spi.AnnotatedMethod; +import javax.enterprise.inject.spi.DeploymentException; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; @@ -30,43 +48,65 @@ public OutgoingPublisher(AnnotatedMethod method, ChannelRouter router) { super(method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router); } - public void connect() { - - try { - //TODO: Types? - Publisher result = (Publisher) method.invoke(beanInstance); + void validate() { + if (channelName == null || channelName.trim().isEmpty()) { + throw new DeploymentException("Missing channel name in annotation @Outgoing, method: " + + method.toString()); + } + if (method.getReturnType().equals(Void.TYPE)) { + throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: " + + method.toString()); + } + } - Config channelConfig = config.get("mp.messaging.outgoing").get(channelName); - ConfigValue connectorName = channelConfig.get("connector").asString(); - if (connectorName.isPresent()) { - subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter() - .getOutgoingConnectorFactory(connectorName.get()), beanManager)) - .getSubscriberBuilder(MpConfig.builder().config(channelConfig).build()); - result.subscribe(subscriberBuilder.build()); - } else { - // Connect to Incoming methods - List incomingSubscribers = getRouter().getIncomingSubscribers(getChannelName()); - if (incomingSubscribers != null) { - for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) { - ReactiveStreams - .fromPublisher(result) - .to(ReactiveStreams.fromSubscriber(s)) - .run(); - } + public void connect() { + Config channelConfig = config.get("mp.messaging.outgoing").get(channelName); + ConfigValue connectorName = channelConfig.get("connector").asString(); + if (connectorName.isPresent()) { + subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter() + .getOutgoingConnectorFactory(connectorName.get()), beanManager)) + .getSubscriberBuilder(MpConfig.builder().config(channelConfig).build()); + getPublisherBuilder().buildRs().subscribe(subscriberBuilder.build()); + } else { + // Connect to Incoming methods + List incomingSubscribers = getRouter().getIncomingSubscribers(getChannelName()); + if (incomingSubscribers != null) { + for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) { + getPublisherBuilder() + .to(ReactiveStreams.fromSubscriber(s)) + .run(); } - } + } + } + private PublisherBuilder getPublisherBuilder() { + try { + Object returnInstance = method.invoke(beanInstance); + if (returnInstance instanceof Publisher) { + // Called once at assembly time. + return ReactiveStreams.fromPublisher((Publisher) returnInstance); + } else if (returnInstance instanceof PublisherBuilder) { + // Called once at assembly time. + return (PublisherBuilder) returnInstance; + } else if (returnInstance instanceof Message) { + //TODO: Supported method signatures in the spec - Message !!! + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } else { + //TODO: Supported method signatures in the spec - Any type + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } } catch (IllegalAccessException | InvocationTargetException e) { throw new RuntimeException(e); } - - } @Override public void subscribe(Subscriber> subscriber) { - + //TODO: Remove whole publisher signature from this class + throw new UnsupportedOperationException(); } } diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java new file mode 100644 index 00000000000..280bd06b0b5 --- /dev/null +++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import io.helidon.common.CollectionsHelper; +import io.helidon.config.Config; +import io.helidon.config.ConfigSources; +import org.apache.kafka.common.serialization.LongSerializer; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class AdHocConfigBuilderTest { + + private static final String TEST_TOPIC_CONFIG = "TEST_TOPIC_CONFIG"; + private static final String TEST_TOPIC_CUSTOM = "TEST_TOPIC_CUSTOM"; + private static final String TEST_KEY = "TEST_KEY"; + private static final String ADDITION_ATTR_1 = "addition-attr1"; + private static final String ADDITION_ATTR_2 = "addition-attr2"; + private static final String ADDITION_ATTR_1_VALUE = "addition-attr1-value"; + private static final String ADDITION_ATTR_2_VALUE = "addition-attr2-value"; + private static final String TEST_CONNECTOR = "test-connector"; + + @Test + void currentContext() { + Map propMap = CollectionsHelper.mapOf( + "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName() + ); + + Config config = Config.builder() + .sources(ConfigSources.create(propMap)) + .build(); + + org.eclipse.microprofile.config.Config c = AdHocConfigBuilder + .from(config.get("mp.messaging.outcoming.test-channel")) + .put(TEST_KEY, TEST_TOPIC_CUSTOM) + .build(); + + assertEquals(TEST_TOPIC_CUSTOM, c.getValue(TEST_KEY, String.class)); + assertEquals(LongSerializer.class.getName(), c.getValue("key.serializer", String.class)); + } + + @Test + void customValueOverride() { + Map propMap = CollectionsHelper.mapOf( + "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG, + "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName() + ); + + Config config = Config.builder() + .sources(ConfigSources.create(propMap)) + .build(); + + org.eclipse.microprofile.config.Config c = AdHocConfigBuilder + .from(config.get("mp.messaging.outcoming.test-channel")) + .put(TEST_KEY, TEST_TOPIC_CUSTOM) + .build(); + + assertEquals(TEST_TOPIC_CUSTOM, c.getValue(TEST_KEY, String.class)); + } + + @Test + void putAllTest() { + Map propMap = CollectionsHelper.mapOf( + "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG + ); + + Map propMap2 = CollectionsHelper.mapOf( + "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_1, ADDITION_ATTR_1_VALUE, + "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_2, ADDITION_ATTR_2_VALUE + ); + + Config config = Config.builder(ConfigSources.create(propMap)) + .disableEnvironmentVariablesSource() + .disableSystemPropertiesSource() + .build(); + Config config2 = Config.builder(ConfigSources.create(propMap2)) + .disableEnvironmentVariablesSource() + .disableSystemPropertiesSource() + .build(); + + org.eclipse.microprofile.config.Config c = AdHocConfigBuilder + .from(config.get("mp.messaging.outcoming.test-channel")) + .putAll(config2.get("mp.messaging.connector." + TEST_CONNECTOR)) + .build(); + + assertEquals(ADDITION_ATTR_1_VALUE, c.getValue(ADDITION_ATTR_1, String.class)); + assertEquals(ADDITION_ATTR_2_VALUE, c.getValue(ADDITION_ATTR_2, String.class)); + } +} \ No newline at end of file diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java index bc69ebaba31..168f1045df7 100644 --- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java +++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.reactive; import io.helidon.common.mapper.Mapper; @@ -66,7 +82,7 @@ public Object map(Object t) { //Filter stream Stage.Filter stageFilter = (Stage.Filter) stage; Predicate predicate = (Predicate) stageFilter.getPredicate(); - //TODO: Ask Tomas this doesn't seems right + //TODO: Valve is deprecated, plan is implement filter in Multi multi = Multi.from(Valves.from(multi).filter(predicate).toPublisher()); } else if (stage instanceof Stage.SubscriberStage) { From 63a337eb8b99d93afc6c5f72cd69ac145fa3bfd2 Mon Sep 17 00:00:00 2001 From: Daniel Kec Date: Thu, 7 Nov 2019 22:56:29 +0100 Subject: [PATCH 07/66] Internal processor impl Signed-off-by: Daniel Kec --- .../messaging/AbstractChannelMethod.java | 224 ++++++++++++++++++ .../AbstractConnectableChannelMethod.java | 84 ------- .../messaging/AdHocConfigBuilder.java | 5 - .../microprofile/messaging/ChannelRouter.java | 69 ++++-- ...criber.java => IncomingChannelMethod.java} | 132 +++++------ .../messaging/InternalProcessor.java | 64 +++++ .../messaging/InternalSubscriber.java | 103 ++++++++ .../messaging/MessagingCdiExtension.java | 11 +- .../messaging/OutgoingChannelMethod.java | 101 ++++++++ .../messaging/OutgoingPublisher.java | 112 --------- .../messaging/ProcessorChannelMethod.java | 120 ++++++++++ .../messaging/AbstractCDITest.java | 31 ++- .../messaging/KafkaCdiExtensionTest.java | 2 +- .../messaging/MessagingCdiExtensionTest.java | 56 ++++- .../messaging/ReactiveEngineTest.java | 21 +- .../messaging/beans/InnerProcessorBean.java | 73 ++++++ .../messaging/beans/InternalChannelsBean.java | 30 ++- .../beans/KafkaProducingConsumingBean.java | 1 - .../NotConnectedIncommingChannelBean.java | 29 +++ .../NotConnectedOutgoingChannelBean.java | 32 +++ .../reactive/HelidonReactiveStreamEngine.java | 4 +- 21 files changed, 979 insertions(+), 325 deletions(-) create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{IncomingSubscriber.java => IncomingChannelMethod.java} (52%) create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java new file mode 100644 index 00000000000..634d0eb1b70 --- /dev/null +++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved. + * + * 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 io.helidon.microprofile.messaging; + +import io.helidon.config.Config; +import org.eclipse.microprofile.reactive.messaging.Message; +import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder; +import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams; +import org.reactivestreams.Publisher; + +import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.BeanManager; +import javax.enterprise.inject.spi.DeploymentException; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +public abstract class AbstractChannelMethod { + + protected String incomingChannelName; + protected String outgoingChannelName; + + protected Bean bean; + private ChannelRouter router; + protected Method method; + protected Object beanInstance; + protected BeanManager beanManager; + protected Config config; + protected Type type; + public boolean connected = false; + + + + public AbstractChannelMethod(String incomingChannelName, String outgoingChannelName, Method method, ChannelRouter router) { + this.incomingChannelName = incomingChannelName; + this.outgoingChannelName = outgoingChannelName; + this.router = router; + this.method = method; + } + + abstract void validate(); + + protected abstract void connect(); + + public void init(BeanManager beanManager, Config config) { + this.beanInstance = getBeanInstance(bean, beanManager); + this.beanManager = beanManager; + this.config = config; + } + + public void setDeclaringBean(Bean bean) { + this.bean = bean; + } + + public Class getDeclaringType() { + return method.getDeclaringClass(); + } + + public String getIncomingChannelName() { + return incomingChannelName; + } + + public String getOutgoingChannelName() { + return outgoingChannelName; + } + + protected PublisherBuilder getPublisherBuilder() { + try { + Object returnInstance = method.invoke(beanInstance); + if (returnInstance instanceof Publisher) { + // Called once at assembly time. + return ReactiveStreams.fromPublisher((Publisher) returnInstance); + } else if (returnInstance instanceof PublisherBuilder) { + // Called once at assembly time. + return (PublisherBuilder) returnInstance; + } else if (returnInstance instanceof Message) { + //TODO: Supported method signatures in the spec - Message !!! + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } else { + //TODO: Supported method signatures in the spec - Any type + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } + } catch (IllegalAccessException | InvocationTargetException e) { + throw new RuntimeException(e); + } + } + + protected Publisher getPublisher() { + try { + Object returnInstance = method.invoke(beanInstance); + if (returnInstance instanceof Publisher) { + // Called once at assembly time. + return (Publisher) returnInstance; + } else if (returnInstance instanceof PublisherBuilder) { + // Called once at assembly time. + return ((PublisherBuilder) returnInstance).buildRs(); + } else if (returnInstance instanceof Message) { + //TODO: Supported method signatures in the spec - Message !!! + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } else { + //TODO: Supported method signatures in the spec - Any type + // Called for each request made by the subscriber + throw new UnsupportedOperationException("Not implemented yet!!"); + } + } catch (IllegalAccessException | InvocationTargetException e) { + throw new RuntimeException(e); + } + } + + protected Object getBeanInstance(Bean bean, BeanManager beanManager) { + javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope()); + Object instance = context.get(bean); + if (instance == null) { + CreationalContext creationalContext = beanManager.createCreationalContext(bean); + instance = beanManager.getReference(bean, bean.getBeanClass(), creationalContext); + } + if (instance == null) { + throw new DeploymentException("Instance of bean " + bean.getName() + " not found"); + } + return instance; + } + + public ChannelRouter getRouter() { + return router; + } + + public enum Type { + /** + * Invoke at: assembly time + * 
Processor<Message<I>, Message<O>> method();
+ * 
Processor<I, O> method();
+ */ + PROCESSOR_VOID_2_PROCESSOR(true), + /** + * Invoke at: Assembly time - + * 
ProcessorBuilder<Message<I>, Message<O>> method();
+ * 

+         */
+        PROCESSOR_VOID_2_PROCESSOR_BUILDER(true),
+        /**
+         * Invoke at: assembly time
+         * 
Publisher<Message<O>> method(Message<I> msg);

+         * 
Publisher<O> method(I payload);

+         */
+        PROCESSOR_PUBLISHER_2_PUBLISHER(true),
+        /**
+         * Invoke at: assembly time
+         * 
PublisherBuilder<O> method(PublisherBuilder<I> pub);

+         */
+        PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true),
+        /**
+         * Invoke at: every incoming
+         * 
Publisher<Message<O>> method(Message<I>msg);

+         * 
Publisher<O> method(I payload);

+         */
+        PROCESSOR_MSG_2_PUBLISHER(false),
+        /**
+         * Invoke at: every incoming
+         * 
Message<O> method(Message<I> msg)

+         * 
O method(I payload)

+         */
+        PROCESSOR_MSG_2_MSG(false),
+        /**
+         * Invoke at: every incoming
+         * 
CompletionStage<Message<O>> method(Message<I> msg)

+         * 
CompletionStage<O> method(I payload)

+         */
+        PROCESSOR_MSG_2_COMPL_STAGE(false),
+
+
+        /**
+         * Invoke at: assembly time
+         * 
Subscriber<Message<I>> method()

+         * 
Subscriber<I> method()

+         */
+        INCOMING_VOID_2_SUBSCRIBER(true),
+        /**
+         * Invoke at: assembly time
+         * 
SubscriberBuilder<Message<I>> method()

+         * 
SubscriberBuilder<I> method()

+         */
+        INCOMING_VOID_2_SUBSCRIBER_BUILDER(true),
+        /**
+         * Invoke at: every incoming
+         * 
void method(I payload)

+         */
+        INCOMING_MSG_2_VOID(false),
+        /**
+         * Invoke at: every incoming
+         * 
CompletionStage<?> method(Message<I>msg)

+         * 
CompletionStage<?> method(I payload)

+         */
+        INCOMING_MSG_2_COMPLETION_STAGE(false);
+
+
+        private boolean invokeAtAssembly;
+
+        Type(boolean invokeAtAssembly) {
+            this.invokeAtAssembly = invokeAtAssembly;
+        }
+
+        public boolean isInvokeAtAssembly() {
+            return invokeAtAssembly;
+        }
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java
deleted file mode 100644
index 315138464e8..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractConnectableChannelMethod.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging;
-
-import io.helidon.config.Config;
-
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.lang.reflect.Method;
-
-public abstract class AbstractConnectableChannelMethod {
-
-    protected final String channelName;
-
-    protected Bean bean;
-    private ChannelRouter router;
-    protected Method method;
-    protected Object beanInstance;
-    protected BeanManager beanManager;
-    protected Config config;
-
-    public AbstractConnectableChannelMethod(String channelName, Method method, ChannelRouter router) {
-        this.router = router;
-        this.method = method;
-        this.channelName = channelName;
-        validate();
-    }
-
-    abstract void validate();
-
-    protected abstract void connect();
-
-    public void init(BeanManager beanManager, Config config) {
-        this.beanInstance = getBeanInstance(bean, beanManager);
-        this.beanManager = beanManager;
-        this.config = config;
-    }
-
-    public void setDeclaringBean(Bean bean) {
-        this.bean = bean;
-    }
-
-    public Class getDeclaringType() {
-        return method.getDeclaringClass();
-    }
-
-    public String getChannelName() {
-        return channelName;
-    }
-
-    protected Object getBeanInstance(Bean bean, BeanManager beanManager) {
-        javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope());
-        Object instance = context.get(bean);
-        if (instance == null) {
-            CreationalContext creationalContext = beanManager.createCreationalContext(bean);
-            instance = beanManager.getReference(bean, bean.getBeanClass(), creationalContext);
-        }
-        if (instance == null) {
-            throw new DeploymentException("Instance of bean " + bean.getName() + " not found");
-        }
-        return instance;
-    }
-
-    public ChannelRouter getRouter() {
-        return router;
-    }
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java
index 899bdeeb86d..b15fb4d819e 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java
@@ -46,11 +46,6 @@ public AdHocConfigBuilder putAll(Config configToPut) {
     }
 
     public org.eclipse.microprofile.config.Config build() {
-        //TODO: There has to be some better way
-//        return MpConfig.builder().config(((MpConfig) mpConfigBuilder
-//                .config(Config.builder().sources(ConfigSources.create(config), ConfigSources.create(properties)).build())
-//                .build()).helidonConfig().get(currentContext)).build();
-//
         Config newConfig = Config.builder(ConfigSources.create(properties), ConfigSources.create(config))
                 .disableEnvironmentVariablesSource()
                 .disableSystemPropertiesSource()
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java
index 462f37f59da..4b2528eed2b 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java
@@ -19,6 +19,8 @@
 import io.helidon.config.Config;
 import io.helidon.microprofile.config.MpConfig;
 import org.eclipse.microprofile.config.ConfigProvider;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.messaging.spi.Connector;
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
@@ -26,6 +28,7 @@
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -33,8 +36,9 @@
 import java.util.Map;
 
 public class ChannelRouter {
-    private List connectableBeanMethods = new ArrayList<>();
-    private Map> incomingSubscriberMap = new HashMap<>();
+    private List connectableBeanMethods = new ArrayList<>();
+    private Map> incomingSubscriberMap = new HashMap<>();
+    private Map> outgoingSubscriberMap = new HashMap<>();
 
     private Map> incomingConnectorFactoryMap = new HashMap<>();
     private Map> outgoingConnectorFactoryMap = new HashMap<>();
@@ -50,21 +54,47 @@ public void connect(BeanManager beanManager) {
         //Needs to be initialized before connecting,
         // fast publishers would call onNext before all bean references are resolved
         connectableBeanMethods.forEach(m -> m.init(beanManager, config));
-        connectableBeanMethods.forEach(AbstractConnectableChannelMethod::connect);
+        connectableBeanMethods.stream().filter(OutgoingChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
+        connectableBeanMethods.stream().filter(IncomingChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
+        connectableBeanMethods.stream().filter(m -> !m.connected).forEach(m -> {
+            throw new DeploymentException("Channel " + m.incomingChannelName + "/" + m.outgoingChannelName
+                    + " has no candidate to connect to method: " + m.method);
+        });
+//        connectableBeanMethods.stream().filter(ProcessorChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
     }
 
     void addIncomingMethod(AnnotatedMethod m) {
-        IncomingSubscriber incomingSubscriber = new IncomingSubscriber(m, this);
-        String channelName = incomingSubscriber.getChannelName();
-        List namedIncomings = incomingSubscriberMap.getOrDefault(channelName, new ArrayList<>());
-        namedIncomings.add(incomingSubscriber);
-        incomingSubscriberMap.put(channelName, namedIncomings);
-        connectableBeanMethods.add(incomingSubscriber);
+        IncomingChannelMethod incomingChannelMethod = new IncomingChannelMethod(m, this);
+        incomingChannelMethod.validate();
+        String channelName = incomingChannelMethod.getIncomingChannelName();
+        getIncomingSubscribers(channelName).add(incomingChannelMethod);
+        connectableBeanMethods.add(incomingChannelMethod);
     }
 
     void addOutgoingMethod(AnnotatedMethod m) {
-        OutgoingPublisher outgoingPublisher = new OutgoingPublisher(m, this);
-        connectableBeanMethods.add(outgoingPublisher);
+        OutgoingChannelMethod outgoingChannelMethod = new OutgoingChannelMethod(m, this);
+        outgoingChannelMethod.validate();
+        String channelName = outgoingChannelMethod.getOutgoingChannelName();
+        getOutgoingSubscribers(channelName).add(outgoingChannelMethod);
+        connectableBeanMethods.add(outgoingChannelMethod);
+    }
+
+    void addProcessorMethod(AnnotatedMethod m) {
+        ProcessorChannelMethod channelMethod = new ProcessorChannelMethod(m, this);
+        channelMethod.validate();
+        getIncomingSubscribers(channelMethod.getIncomingChannelName()).add(channelMethod);
+        getOutgoingSubscribers(channelMethod.getOutgoingChannelName()).add(channelMethod);
+        connectableBeanMethods.add(channelMethod);
+    }
+
+    public void addMethod(AnnotatedMethod m) {
+        if (m.isAnnotationPresent(Incoming.class) && m.isAnnotationPresent(Outgoing.class)) {
+            this.addProcessorMethod(m);
+        } else if (m.isAnnotationPresent(Incoming.class)) {
+            this.addIncomingMethod(m);
+        } else if (m.isAnnotationPresent(Outgoing.class)) {
+            this.addOutgoingMethod(m);
+        }
     }
 
     void addConnectorFactory(Bean bean) {
@@ -78,8 +108,20 @@ void addConnectorFactory(Bean bean) {
         }
     }
 
-    public List getIncomingSubscribers(String channelName) {
-        return incomingSubscriberMap.get(channelName);
+    public List getIncomingSubscribers(String channelName) {
+        return getOrCreateList(channelName, incomingSubscriberMap);
+    }
+
+    public List getOutgoingSubscribers(String channelName) {
+        return getOrCreateList(channelName, outgoingSubscriberMap);
+    }
+
+    private static  List getOrCreateList(String key, Map> map) {
+        List list = map.getOrDefault(key, new ArrayList<>());
+        if (list.isEmpty()) {
+            map.put(key, list);
+        }
+        return list;
     }
 
     public Bean getIncomingConnectorFactory(String connectorName) {
@@ -89,5 +131,4 @@ public Bean getIncomingConnectorFactory(String connectorName) {
     public Bean getOutgoingConnectorFactory(String connectorName) {
         return outgoingConnectorFactoryMap.get(connectorName);
     }
-
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
similarity index 52%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
index 0f74be5ec43..d6149bd1e5d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
@@ -16,8 +16,6 @@
 
 package io.helidon.microprofile.messaging;
 
-import io.helidon.common.context.Context;
-import io.helidon.common.context.Contexts;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
@@ -25,42 +23,68 @@
 import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.util.UUID;
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.CompletionStage;
 import java.util.logging.Logger;
 
 /**
  * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming}
  * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method
  */
-public class IncomingSubscriber extends AbstractConnectableChannelMethod implements Subscriber {
+public class IncomingChannelMethod extends AbstractChannelMethod {
 
-    private static final Logger LOGGER = Logger.getLogger(IncomingSubscriber.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(IncomingChannelMethod.class.getName());
 
     private PublisherBuilder> publisherBuilder;
-    private Subscription subscription;
-    private Long chunkSize = 5L;
-    private Long chunkPosition = 0L;
+    private Subscriber subscriber;
 
-    public IncomingSubscriber(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getAnnotation(Incoming.class).value(), method.getJavaMember(), router);
+    public IncomingChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(method.getAnnotation(Incoming.class).value(), null, method.getJavaMember(), router);
+        resolveSignatureType();
     }
 
     void validate() {
-        if (channelName == null || channelName.trim().isEmpty()) {
+        if (incomingChannelName == null || incomingChannelName.trim().isEmpty()) {
             throw new DeploymentException("Missing channel name in annotation @Incoming on method "
                     + method.toString());
         }
     }
 
+    @Override
+    public void init(BeanManager beanManager, Config config) {
+        super.init(beanManager, config);
+        if (type.isInvokeAtAssembly()) {
+            // Incoming methods returning custom subscriber
+            try {
+                switch (type) {
+                    case INCOMING_VOID_2_SUBSCRIBER:
+                        subscriber = (Subscriber) method.invoke(beanInstance);
+                        break;
+                    case INCOMING_VOID_2_SUBSCRIBER_BUILDER:
+                        subscriber = ((SubscriberBuilder) method.invoke(beanInstance)).build();
+                        break;
+                    default:
+                        throw new DeploymentException("Unsupported method signature " + method);
+                }
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(e);
+            }
+        } else {
+            // Create brand new subscriber
+            subscriber = new InternalSubscriber(method, beanInstance);
+        }
+    }
+
     @Override
     protected void connect() {
-        Config channelConfig = config.get("mp.messaging.incoming").get(channelName);
+        Config channelConfig = config.get("mp.messaging.incoming").get(incomingChannelName);
         ConfigValue connectorName = channelConfig.get("connector").asString();
         if (connectorName.isPresent()) {
             Config connectorConfig = config.get("mp.messaging.connector")
@@ -69,7 +93,7 @@ protected void connect() {
                     AdHocConfigBuilder
                             .from(channelConfig)
                             //It seams useless but its required by the spec
-                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, channelName)
+                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, incomingChannelName)
                             .putAll(connectorConfig)
                             .build();
             publisherBuilder =
@@ -79,75 +103,33 @@ protected void connect() {
                             .getPublisherBuilder(augmentedConfig);
 
             //TODO: iterate over multiple publishers / does spec even support multiple publishers?
-            publisherBuilder.buildRs().subscribe(this);
-            LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", channelName, connectorName.get(), method.toString()));
+            publisherBuilder.buildRs().subscribe(this.subscriber);
+            LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", incomingChannelName, connectorName.get(), method.toString()));
+            connected = true;
         }
-    }
-
 
-    public PublisherBuilder> getPublisherBuilder() {
-        return publisherBuilder;
     }
 
-    private void incrementAndCheckChunkPosition() {
-        chunkPosition++;
-        if (chunkPosition >= chunkSize) {
-            chunkPosition = 0L;
-            subscription.request(chunkSize);
-        }
+    public Subscriber getSubscriber() {
+        return subscriber;
     }
 
-    @Override
-    public void onNext(Object message) {
-        try {
-            final Object paramValue;
-            Class paramType = this.method.getParameterTypes()[0];
-
-            if (paramType != Message.class && !(message instanceof Message)) {
-                paramValue = paramType.cast(message);
-
-            } else if (paramType == Message.class && message instanceof Message) {
-                paramValue = paramType.cast(message);
-
-            } else if (paramType != Message.class && message instanceof Message) {
-                paramValue = paramType.cast(((Message) message).getPayload());
-
-            } else if (paramType == Message.class && !(message instanceof Message)) {
-                paramValue = paramType.cast(Message.of(message));
-
-            } else {
-                paramValue = message;
+    protected void resolveSignatureType() {
+        Class returnType = this.method.getReturnType();
+        Class parameterType = this.method.getParameterTypes()[0];
+        if (Void.TYPE.equals(parameterType)) {
+            if (Subscriber.class.equals(returnType)) {
+                this.type = Type.INCOMING_VOID_2_SUBSCRIBER;
+            } else if (SubscriberBuilder.class.equals(returnType)) {
+                this.type = Type.INCOMING_VOID_2_SUBSCRIBER_BUILDER;
+            }
+        } else {
+            if (CompletionStage.class.equals(returnType)) {
+                this.type = Type.INCOMING_MSG_2_COMPLETION_STAGE;
+            } else if (Void.TYPE.equals(returnType)) {
+                this.type = Type.INCOMING_MSG_2_VOID;
             }
-
-            Context parentContext = Context.create();
-            Context context = Context
-                    .builder()
-                    .parent(parentContext)
-                    .id(parentContext.id() + ":message-" + UUID.randomUUID().toString())
-                    .build();
-            Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, paramValue));
-            incrementAndCheckChunkPosition();
-        } catch (Exception e) {
-            //Notify publisher to stop sending
-            subscription.cancel();
-            throw new RuntimeException(e);
         }
     }
 
-    @Override
-    public void onError(Throwable t) {
-        throw new RuntimeException(t);
-    }
-
-    @Override
-    public void onSubscribe(Subscription s) {
-        subscription = s;
-        //First chunk request
-        subscription.request(chunkSize);
-    }
-
-    @Override
-    public void onComplete() {
-    }
-
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
new file mode 100644
index 00000000000..6fea0624043
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.lang.reflect.InvocationTargetException;
+
+public class InternalProcessor implements Processor {
+
+
+    private ProcessorChannelMethod processorChannelMethod;
+    private Subscriber subscriber;
+
+    public InternalProcessor(ProcessorChannelMethod processorChannelMethod) {
+        this.processorChannelMethod = processorChannelMethod;
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        subscriber = s;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        subscriber.onSubscribe(s);
+    }
+
+    @Override
+    public void onNext(Object incomingValue) {
+        try {
+            Object processedValue = processorChannelMethod.method.invoke(processorChannelMethod.beanInstance, incomingValue);
+            subscriber.onNext(processedValue);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            subscriber.onError(e);
+        }
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java
new file mode 100644
index 00000000000..6786ad4da90
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import io.helidon.common.context.Context;
+import io.helidon.common.context.Contexts;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+public class InternalSubscriber implements Subscriber {
+
+    private Subscription subscription;
+    private Long chunkSize = 5L;
+    private Long chunkPosition = 0L;
+    private Method method;
+    private Object beanInstance;
+
+    public InternalSubscriber(Method method, Object beanInstance) {
+        this.method = method;
+        this.beanInstance = beanInstance;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        subscription = s;
+        //First chunk request
+        subscription.request(chunkSize);
+    }
+
+    @Override
+    public void onNext(Object message) {
+        try {
+            final Object paramValue;
+            Class paramType = this.method.getParameterTypes()[0];
+
+            if (paramType != Message.class && !(message instanceof Message)) {
+                paramValue = paramType.cast(message);
+
+            } else if (paramType == Message.class && message instanceof Message) {
+                paramValue = paramType.cast(message);
+
+            } else if (paramType != Message.class && message instanceof Message) {
+                paramValue = paramType.cast(((Message) message).getPayload());
+
+            } else if (paramType == Message.class && !(message instanceof Message)) {
+                paramValue = paramType.cast(Message.of(message));
+
+            } else {
+                paramValue = message;
+            }
+
+            Context parentContext = Context.create();
+            Context context = Context
+                    .builder()
+                    .parent(parentContext)
+                    .id(parentContext.id() + ":message-" + UUID.randomUUID().toString())
+                    .build();
+            Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, paramValue));
+            incrementAndCheckChunkPosition();
+        } catch (Exception e) {
+            //Notify publisher to stop sending
+            subscription.cancel();
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        //TODO: Propagate error
+        throw new RuntimeException(t);
+    }
+
+    @Override
+    public void onComplete() {
+
+    }
+
+    private void incrementAndCheckChunkPosition() {
+        chunkPosition++;
+        if (chunkPosition >= chunkSize) {
+            chunkPosition = 0L;
+            subscription.request(chunkSize);
+        }
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
index c046669a0a6..a828d739420 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
@@ -39,15 +39,8 @@ public class MessagingCdiExtension implements Extension {
     private ChannelRouter channelRouter = new ChannelRouter();
 
     private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, Outgoing.class}) ProcessAnnotatedType pat) {
-        pat.getAnnotatedType().getMethods()
-                .stream()
-                .filter(m -> m.isAnnotationPresent(Incoming.class))
-                .forEach(m -> channelRouter.addIncomingMethod(m));
-
-        pat.getAnnotatedType().getMethods()
-                .stream()
-                .filter(m -> m.isAnnotationPresent(Outgoing.class))
-                .forEach(m -> channelRouter.addOutgoingMethod(m));
+        // Lookup channel methods
+        pat.getAnnotatedType().getMethods().forEach(m -> channelRouter.addMethod(m));
     }
 
     public void onProcessBean(@Observes ProcessManagedBean event) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java
new file mode 100644
index 00000000000..badd7f14ef4
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import io.helidon.config.Config;
+import io.helidon.config.ConfigValue;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
+import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+public class OutgoingChannelMethod extends AbstractChannelMethod {
+
+    private static final Logger LOGGER = Logger.getLogger(OutgoingChannelMethod.class.getName());
+
+    private SubscriberBuilder, Void> subscriberBuilder;
+
+    public OutgoingChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(null, method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router);
+    }
+
+    void validate() {
+        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
+            throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
+                    + method.toString());
+        }
+        if (method.getReturnType().equals(Void.TYPE)) {
+            throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: "
+                    + method.toString());
+        }
+    }
+
+    public void connect() {
+        Config channelConfig = config.get("mp.messaging.outgoing").get(outgoingChannelName);
+        ConfigValue connectorName = channelConfig.get("connector").asString();
+        if (connectorName.isPresent()) {
+            //Connect to connector
+            Config connectorConfig = config
+                    .get("mp.messaging.connector")
+                    .get(connectorName.get());
+            org.eclipse.microprofile.config.Config augmentedConfig =
+                    AdHocConfigBuilder
+                            .from(channelConfig)
+                            //It seams useless but its required by the spec
+                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, outgoingChannelName)
+                            .putAll(connectorConfig)
+                            .build();
+            subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
+                    .getOutgoingConnectorFactory(connectorName.get()), beanManager))
+                    .getSubscriberBuilder(augmentedConfig);
+            getPublisherBuilder()
+                    .buildRs()
+                    .subscribe(subscriberBuilder.build());
+            connected = true;
+        } else {
+            // Connect to Incoming methods with publisher
+            List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
+            if (incomingChannelMethods != null) {
+                for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
+                    System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
+
+                    Publisher publisher = getPublisher();
+                    if(s instanceof ProcessorChannelMethod){
+                        // Processors managing subscribing
+                        ((ProcessorChannelMethod)s).setPublisher(publisher);
+                    }else{
+                        // TODO: Move subscribing to Incoming methods to align with processors
+                        publisher.subscribe(s.getSubscriber());
+                    }
+                    s.connected = true;
+                    connected = true;
+                }
+            }
+
+        }
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java
deleted file mode 100644
index f471a95bb2b..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingPublisher.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging;
-
-import io.helidon.config.Config;
-import io.helidon.config.ConfigValue;
-import io.helidon.microprofile.config.MpConfig;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Logger;
-
-//TODO: remove publisher implementation, it doesnt make sense here(rename class too)
-public class OutgoingPublisher extends AbstractConnectableChannelMethod implements Publisher> {
-
-    private static final Logger LOGGER = Logger.getLogger(OutgoingPublisher.class.getName());
-
-    private List>> subscriberList = new ArrayList<>();
-    private SubscriberBuilder, Void> subscriberBuilder;
-
-    public OutgoingPublisher(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router);
-    }
-
-    void validate() {
-        if (channelName == null || channelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
-                    + method.toString());
-        }
-        if (method.getReturnType().equals(Void.TYPE)) {
-            throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: "
-                    + method.toString());
-        }
-    }
-
-    public void connect() {
-        Config channelConfig = config.get("mp.messaging.outgoing").get(channelName);
-        ConfigValue connectorName = channelConfig.get("connector").asString();
-        if (connectorName.isPresent()) {
-            subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
-                    .getOutgoingConnectorFactory(connectorName.get()), beanManager))
-                    .getSubscriberBuilder(MpConfig.builder().config(channelConfig).build());
-            getPublisherBuilder().buildRs().subscribe(subscriberBuilder.build());
-        } else {
-            // Connect to Incoming methods
-            List incomingSubscribers = getRouter().getIncomingSubscribers(getChannelName());
-            if (incomingSubscribers != null) {
-                for (IncomingSubscriber s : getRouter().getIncomingSubscribers(getChannelName())) {
-                    getPublisherBuilder()
-                            .to(ReactiveStreams.fromSubscriber(s))
-                            .run();
-                }
-            }
-
-        }
-    }
-
-    private PublisherBuilder getPublisherBuilder() {
-        try {
-            Object returnInstance = method.invoke(beanInstance);
-            if (returnInstance instanceof Publisher) {
-                // Called once at assembly time.
-                return ReactiveStreams.fromPublisher((Publisher) returnInstance);
-            } else if (returnInstance instanceof PublisherBuilder) {
-                // Called once at assembly time.
-                return (PublisherBuilder) returnInstance;
-            } else if (returnInstance instanceof Message) {
-                //TODO: Supported method signatures in the spec - Message !!!
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            } else {
-                //TODO: Supported method signatures in the spec - Any type
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            }
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    @Override
-    public void subscribe(Subscriber> subscriber) {
-        //TODO: Remove whole publisher signature from this class
-        throw new UnsupportedOperationException();
-    }
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
new file mode 100644
index 00000000000..1b8319d28b3
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import io.helidon.config.Config;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.List;
+import java.util.concurrent.CompletionStage;
+
+public class ProcessorChannelMethod extends IncomingChannelMethod {
+
+    private SubscriberBuilder, Void> subscriberBuilder;
+    private Processor processor;
+    private Publisher publisher;
+
+    public ProcessorChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(method, router);
+        super.outgoingChannelName =
+                method.getAnnotation(Outgoing.class).value();
+        resolveSignatureType();
+    }
+
+    @Override
+    public void init(BeanManager beanManager, Config config) {
+        super.init(beanManager, config);
+        if (type.isInvokeAtAssembly()) {
+            // TODO: Incoming methods returning custom processor
+            throw new UnsupportedOperationException("Not implemented yet!");
+        } else {
+            // Create brand new subscriber
+            processor = new InternalProcessor(this);
+        }
+    }
+
+    @Override
+    void validate() {
+        super.validate();
+        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
+            throw new DeploymentException("Missing channel name in annotation @Outgoing on method "
+                    + method.toString());
+        }
+        if (this.method.getParameterTypes().length > 1) {
+            throw new DeploymentException("Bad processor method signature, "
+                    + "wrong number of parameters, only one or none allowed."
+                    + method.toString());
+        }
+    }
+
+    @Override
+    protected void connect() {
+        // Connect to Incoming methods with publisher
+        List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
+        if (incomingChannelMethods != null) {
+            for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
+                System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
+                connected = true;
+                s.connected = true;
+                processor.subscribe(s.getSubscriber());
+                publisher.subscribe(processor);
+            }
+        }
+
+    }
+
+    public void setPublisher(Publisher publisher) {
+        this.publisher = publisher;
+    }
+
+    protected void resolveSignatureType() {
+        Class returnType = this.method.getReturnType();
+        Class parameterType = this.method.getParameterTypes()[0];
+        if (Void.TYPE.equals(parameterType)) {
+            if (Processor.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_VOID_2_PROCESSOR;
+            } else if (ProcessorBuilder.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER;
+            } else {
+                throw new DeploymentException("Bad processor method signature " + method);
+            }
+        } else if (Publisher.class.equals(parameterType) && Publisher.class.equals(returnType)) {
+            this.type = Type.PROCESSOR_PUBLISHER_2_PUBLISHER;
+        } else if (PublisherBuilder.class.equals(parameterType) && PublisherBuilder.class.equals(returnType)) {
+            this.type = Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER;
+        } else {
+            if (Publisher.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_MSG_2_PUBLISHER;
+            } else if (CompletionStage.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_MSG_2_COMPL_STAGE;
+            } else {
+                this.type = Type.PROCESSOR_MSG_2_MSG;
+            }
+        }
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index ad885573f6f..330d80cbec1 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
 
 import io.helidon.config.Config;
@@ -16,6 +32,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.annotation.Annotation;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Properties;
 import java.util.Set;
@@ -51,13 +68,15 @@ public String value() {
         }
     };
 
-    private SeContainer cdiContainer;
+    protected SeContainer cdiContainer;
 
-    protected void cdiConfig(Properties p){
+    protected void cdiConfig(Properties p) {
         //Default config
     }
 
-    abstract void cdiBeanClasses(Set> classes);
+    protected void cdiBeanClasses(Set> classes) {
+
+    }
 
     @BeforeEach
     public void setUp() {
@@ -75,10 +94,14 @@ public void tearDown() {
         }
     }
 
-    protected  void forEachBean(Class beanType, Annotation annotation, Consumer consumer){
+    protected  void forEachBean(Class beanType, Annotation annotation, Consumer consumer) {
         cdiContainer.select(beanType, annotation).stream().forEach(consumer);
     }
 
+    public static SeContainer startCdiContainer(Properties p, Class... beanClasses) {
+        return startCdiContainer(p, new HashSet<>(Arrays.asList(beanClasses)));
+    }
+
     public static SeContainer startCdiContainer(Properties p, Set> beanClasses) {
         Config config = Config.builder()
                 .sources(ConfigSources.create(p))
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java
index 82db5720d99..15a1adb7f3b 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java
@@ -63,7 +63,7 @@ protected void cdiConfig(Properties p) {
     }
 
     @Override
-    void cdiBeanClasses(Set> classes) {
+    protected void cdiBeanClasses(Set> classes) {
         classes.add(KafkaConnectorFactory.class);
         classes.add(KafkaConsumingBean.class);
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java
index 24db80fdeda..9f21b3dc855 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java
@@ -1,25 +1,71 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
 
+import io.helidon.microprofile.messaging.beans.InnerProcessorBean;
 import io.helidon.microprofile.messaging.beans.InternalChannelsBean;
+import io.helidon.microprofile.messaging.beans.NotConnectedIncommingChannelBean;
+import io.helidon.microprofile.messaging.beans.NotConnectedOutgoingChannelBean;
 import org.junit.jupiter.api.Test;
 
-import java.util.Set;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class MessagingCdiExtensionTest extends AbstractCDITest {
 
     @Override
-    void cdiBeanClasses(Set> classes) {
-        classes.add(InternalChannelsBean.class);
+    public void setUp() {
+        //Starting container manually
     }
 
     @Test
     void internalChannelsInSameBeanTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(new Properties(), InternalChannelsBean.class);
+
         // Wait till all messages are delivered
-        assertTrue(InternalChannelsBean.selfCallLatch.await(10, TimeUnit.SECONDS)
+        assertTrue(InternalChannelsBean.publisher_string_latch.await(2, TimeUnit.SECONDS)
                 , "All messages not delivered in time, number of unreceived messages: "
-                        + InternalChannelsBean.selfCallLatch.getCount());
+                        + InternalChannelsBean.publisher_string_latch.getCount());
+    }
+
+    @Test
+    void processorInSameBeanTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(new Properties(), InnerProcessorBean.class);
+
+        // Wait till all messages are delivered
+        assertTrue(InnerProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
+                , "All messages not delivered in time, number of unreceived messages: "
+                        + InnerProcessorBean.testLatch.getCount());
+    }
+
+    @Test
+    void notConnectedIncomingChannelTest() {
+        assertThrows(DeploymentException.class, () ->
+                cdiContainer = startCdiContainer(new Properties(), NotConnectedIncommingChannelBean.class));
+    }
+
+    @Test
+    void notConnectedOutgoingChannelTest() {
+        assertThrows(DeploymentException.class, () ->
+                cdiContainer = startCdiContainer(new Properties(), NotConnectedOutgoingChannelBean.class));
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
index 70f9df9c8e9..0524a56e453 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
 
 import io.helidon.common.reactive.microprofile.HelidonReactiveStreamEngine;
@@ -16,11 +32,6 @@
 
 public class ReactiveEngineTest {
 
-    @Test
-    void testSmallRye() {
-//        testEngine(new io.smallrye.reactive.streams.Engine());
-    }
-
     @Test
     void testTestHelidon() {
         testEngine(new HelidonReactiveStreamEngine());
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java
new file mode 100644
index 00000000000..4a1513f467e
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ */
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.beans;
+
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+public class InnerProcessorBean {
+
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
+    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toUpperCase).collect(Collectors.toSet());
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
+
+    @Outgoing("inner-processor")
+    public Publisher produceMessage() {
+        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public String process(String msg) {
+        return msg.toUpperCase();
+    }
+
+    @Incoming("inner-consumer")
+    public void receiveMessage(String msg) {
+        assertTrue(TEST_DATA.contains(msg.toLowerCase()), "Unexpected message received");
+        testLatch.countDown();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java
index 357ef8be3f6..447a6608596 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.beans;
 
 import io.helidon.common.reactive.Multi;
@@ -18,18 +34,16 @@
 public class InternalChannelsBean {
 
     private static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2"));
-    public static CountDownLatch selfCallLatch = new CountDownLatch(TEST_DATA.size());
+    public static CountDownLatch publisher_string_latch = new CountDownLatch(TEST_DATA.size());
 
-    @Outgoing("self-call-channel")
+    @Outgoing("intenal-publisher-string")
     public Publisher produceMessage() {
-//        return Flowable.fromIterable(TEST_DATA);
-        //Nobody needs javarx
-        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+        return Multi.justMP(TEST_DATA.toArray(new String[0]));
     }
 
-    @Incoming("self-call-channel")
-    public void receiveFromSelfMethod(String msg) {
+    @Incoming("intenal-publisher-string")
+    public void receiveMethod(String msg) {
         assertTrue(TEST_DATA.contains(msg), "Unexpected message received");
-        selfCallLatch.countDown();
+        publisher_string_latch.countDown();
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java
index 4de9f5e506f..041c68f7a08 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java
@@ -30,7 +30,6 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @ApplicationScoped
-//TODO: Implement test
 public class KafkaProducingConsumingBean {
 
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java
new file mode 100644
index 00000000000..7cc57fe966d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.beans;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class NotConnectedIncommingChannelBean {
+
+    @Incoming("not-existing-channel")
+    public void receiveMethod(String msg) {
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java
new file mode 100644
index 00000000000..a4b79f35754
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.beans;
+
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class NotConnectedOutgoingChannelBean {
+
+    @Outgoing("not-existing-channel")
+    public Publisher produceMessage() {
+        return Multi.justMP("t1", "t2");
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 7ccee8b2da8..6d8e9e2f372 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -44,12 +44,12 @@ public  Publisher buildPublisher(Graph graph) throws UnsupportedStageExcep
 
     @Override
     public  SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException {
-        return null;
+        throw new UnsupportedOperationException("Not implemented yet!!!");
     }
 
     @Override
     public  Processor buildProcessor(Graph graph) throws UnsupportedStageException {
-        return null;
+        throw new UnsupportedOperationException("Not implemented yet!!!");
     }
 
     @Override

From 92ae9b86c443f01cdeb58770b4827dbd62d22612 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 8 Nov 2019 15:06:33 +0100
Subject: [PATCH 08/66] Passing 8/14 tck tests

Signed-off-by: Daniel Kec 
---
 microprofile/messaging/pom.xml                | 11 ---
 .../ConnectorDownstreamProcessor.java         | 32 ++++++++
 .../messaging/IncomingChannelMethod.java      |  2 +-
 .../messaging/InternalProcessor.java          | 10 ++-
 .../microprofile/messaging/MessageUtils.java  | 40 ++++++++++
 .../messaging/ProcessorChannelMethod.java     | 77 ++++++++++++++++---
 .../messaging/AbstractCDITest.java            | 17 ++--
 .../messaging/AdHocConfigBuilderTest.java     |  9 ++-
 .../messaging/ReactiveEngineTest.java         | 19 +++--
 .../helidon/microprofile/messaging/Test.java  | 14 ----
 .../messaging/connector/ConnectedBean.java    | 39 ++++++++++
 .../connector/ConnectedOnlyProcessorBean.java | 34 ++++++++
 .../connector/ConnectedProcessorBean.java     | 58 ++++++++++++++
 .../messaging/connector/ConnectorTest.java    | 72 +++++++++++++++++
 .../connector/IterableConnector.java          | 59 ++++++++++++++
 .../InnerChannelTest.java}                    | 27 +++----
 .../{beans => inner}/InnerProcessorBean.java  |  2 +-
 .../InternalChannelsBean.java                 |  2 +-
 .../NotConnectedIncommingChannelBean.java     |  2 +-
 .../NotConnectedOutgoingChannelBean.java      |  2 +-
 .../{ => kafka}/KafkaCdiExtensionTest.java    | 38 +++++----
 .../{beans => kafka}/KafkaConsumingBean.java  |  5 +-
 .../KafkaProducingConsumingBean.java          |  5 +-
 .../reactive/HelidonReactiveStreamEngine.java | 68 +++++++++++++++-
 ...e.streams.operators.ReactiveStreamsFactory | 17 ----
 25 files changed, 549 insertions(+), 112 deletions(-)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
 delete mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedOnlyProcessorBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedProcessorBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/IterableConnector.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{MessagingCdiExtensionTest.java => inner/InnerChannelTest.java} (67%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => inner}/InnerProcessorBean.java (98%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => inner}/InternalChannelsBean.java (97%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => inner}/NotConnectedIncommingChannelBean.java (94%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => inner}/NotConnectedOutgoingChannelBean.java (95%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{ => kafka}/KafkaCdiExtensionTest.java (73%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => kafka}/KafkaConsumingBean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{beans => kafka}/KafkaProducingConsumingBean.java (93%)
 delete mode 100644 microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory

diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml
index 81c0a7b5512..987116e7e03 100644
--- a/microprofile/messaging/pom.xml
+++ b/microprofile/messaging/pom.xml
@@ -94,17 +94,6 @@
             internal-test-libs
             test
         
-        
-        
-        
-        
-        
-        
-        
-        
-        
-        
-        
         
             org.jboss.weld
             weld-junit5
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java
new file mode 100644
index 00000000000..3fcb81aac3f
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+
+public class ConnectorDownstreamProcessor extends InternalProcessor {
+
+    public ConnectorDownstreamProcessor(ProcessorChannelMethod processorChannelMethod) {
+        super(processorChannelMethod);
+    }
+
+    @Override
+    protected Object wrapValue(Object value) {
+        return Message.of(value);
+    }
+}
\ No newline at end of file
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
index d6149bd1e5d..ba187147ea1 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
@@ -42,7 +42,7 @@ public class IncomingChannelMethod extends AbstractChannelMethod {
 
     private static final Logger LOGGER = Logger.getLogger(IncomingChannelMethod.class.getName());
 
-    private PublisherBuilder> publisherBuilder;
+    protected PublisherBuilder> publisherBuilder;
     private Subscriber subscriber;
 
     public IncomingChannelMethod(AnnotatedMethod method, ChannelRouter router) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
index 6fea0624043..d7dc88e3c16 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
@@ -45,13 +45,19 @@ public void onSubscribe(Subscription s) {
     @Override
     public void onNext(Object incomingValue) {
         try {
-            Object processedValue = processorChannelMethod.method.invoke(processorChannelMethod.beanInstance, incomingValue);
-            subscriber.onNext(processedValue);
+            //TODO: Has to be always one param in the processor, validate and propagate better
+            Class paramType = processorChannelMethod.method.getParameterTypes()[0];
+            Object processedValue = processorChannelMethod.method.invoke(processorChannelMethod.beanInstance, MessageUtils.unwrap(incomingValue, paramType));
+            subscriber.onNext(wrapValue(processedValue));
         } catch (IllegalAccessException | InvocationTargetException e) {
             subscriber.onError(e);
         }
     }
 
+    protected Object wrapValue(Object value) {
+        return value;
+    }
+
     @Override
     public void onError(Throwable t) {
         subscriber.onError(t);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
new file mode 100644
index 00000000000..281a541b961
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+
+public class MessageUtils {
+    public static Object unwrap(Object value, Class type) {
+        if (type.equals(Message.class)) {
+            if (value instanceof Message) {
+                return type.cast(value);
+            } else {
+                return Message.of(value);
+            }
+        } else {
+            if (value instanceof Message) {
+                return type.cast(((Message) value).getPayload());
+            } else if (type.isInstance(value)) {
+                return type.cast(value);
+            } else {
+                throw new RuntimeException("Type mismatch " + value.getClass() + "cant be cast to " + type);
+            }
+        }
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
index 1b8319d28b3..fc6b0cf7c5f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
@@ -17,13 +17,18 @@
 package io.helidon.microprofile.messaging;
 
 import io.helidon.config.Config;
+import io.helidon.config.ConfigValue;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
+import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
+import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
@@ -31,9 +36,12 @@
 
 import java.util.List;
 import java.util.concurrent.CompletionStage;
+import java.util.logging.Logger;
 
 public class ProcessorChannelMethod extends IncomingChannelMethod {
 
+    private static final Logger LOGGER = Logger.getLogger(ProcessorChannelMethod.class.getName());
+
     private SubscriberBuilder, Void> subscriberBuilder;
     private Processor processor;
     private Publisher publisher;
@@ -73,18 +81,67 @@ void validate() {
 
     @Override
     protected void connect() {
-        // Connect to Incoming methods with publisher
-        List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
-        if (incomingChannelMethods != null) {
-            for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
-                System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
-                connected = true;
-                s.connected = true;
-                processor.subscribe(s.getSubscriber());
-                publisher.subscribe(processor);
-            }
+        //TODO: Extract connectors to UpstreamConnectorChannel and DownstreamConnectorChannel also rename channelMethods to channels only
+        //Connect to upstream incoming connector if any
+        Config incomingChannelConfig = config.get("mp.messaging.incoming").get(incomingChannelName);
+        ConfigValue connectorName = incomingChannelConfig.get("connector").asString();
+        if (connectorName.isPresent()) {
+            Config connectorConfig = config.get("mp.messaging.connector")
+                    .get(connectorName.get());
+            org.eclipse.microprofile.config.Config augmentedConfig =
+                    AdHocConfigBuilder
+                            .from(incomingChannelConfig)
+                            //It seams useless but its required by the spec
+                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, incomingChannelName)
+                            .putAll(connectorConfig)
+                            .build();
+            publisherBuilder =
+                    ((IncomingConnectorFactory) getBeanInstance(
+                            getRouter().getIncomingConnectorFactory(connectorName.get()),
+                            beanManager))
+                            .getPublisherBuilder(augmentedConfig);
+
+            //TODO: iterate over multiple publishers / does spec even support multiple publishers?
+            publisher = (Publisher) publisherBuilder.buildRs();
+            LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", incomingChannelName, connectorName.get(), method.toString()));
+            connected = true;
         }
 
+        //Connect to downstream outgoing connector if any
+        Config outgoingChannelConfig = config.get("mp.messaging.outgoing").get(outgoingChannelName);
+        ConfigValue outgoingConnectorName = outgoingChannelConfig.get("connector").asString();
+        if (outgoingConnectorName.isPresent()) {
+            //Connect to connector
+            Config connectorConfig = config
+                    .get("mp.messaging.connector")
+                    .get(outgoingConnectorName.get());
+            org.eclipse.microprofile.config.Config augmentedConfig =
+                    AdHocConfigBuilder
+                            .from(outgoingChannelConfig)
+                            //It seams useless but its required by the spec
+                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, outgoingChannelName)
+                            .putAll(connectorConfig)
+                            .build();
+            subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
+                    .getOutgoingConnectorFactory(outgoingConnectorName.get()), beanManager))
+                    .getSubscriberBuilder(augmentedConfig);
+            processor = new ConnectorDownstreamProcessor(this);
+            processor.subscribe((Subscriber) subscriberBuilder.build());
+            connected = true;
+        } else {
+            // Connect to downstream Incoming methods with publisher
+            List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
+            if (incomingChannelMethods != null) {
+                for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
+                    System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
+                    connected = true;
+                    s.connected = true;
+                    processor.subscribe(s.getSubscriber());
+                }
+            }
+        }
+        //Publisher is populated by upstream outgoing(OutgoingChannelMethod) or connector
+        publisher.subscribe(processor);
     }
 
     public void setPublisher(Publisher publisher) {
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index 330d80cbec1..8bf1be680ca 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -21,6 +21,7 @@
 import io.helidon.messaging.kafka.connector.KafkaConnectorFactory;
 import io.helidon.microprofile.config.MpConfig;
 import io.helidon.microprofile.config.MpConfigProviderResolver;
+import io.helidon.microprofile.messaging.kafka.KafkaCdiExtensionTest;
 import io.helidon.microprofile.server.Server;
 import org.eclipse.microprofile.reactive.messaging.spi.Connector;
 import org.junit.jupiter.api.AfterEach;
@@ -33,8 +34,10 @@
 import java.io.InputStream;
 import java.lang.annotation.Annotation;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Properties;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.logging.LogManager;
@@ -70,8 +73,8 @@ public String value() {
 
     protected SeContainer cdiContainer;
 
-    protected void cdiConfig(Properties p) {
-        //Default config
+    protected Map cdiConfig() {
+        return Collections.emptyMap();
     }
 
     protected void cdiBeanClasses(Set> classes) {
@@ -80,10 +83,10 @@ protected void cdiBeanClasses(Set> classes) {
 
     @BeforeEach
     public void setUp() {
-        Properties p = new Properties();
+        Map p = new HashMap<>();
         Set> classes = new HashSet<>();
         cdiBeanClasses(classes);
-        cdiConfig(p);
+        p.putAll(cdiConfig());
         cdiContainer = startCdiContainer(p, classes);
     }
 
@@ -98,11 +101,11 @@ protected  void forEachBean(Class beanType, Annotation annotation, Consume
         cdiContainer.select(beanType, annotation).stream().forEach(consumer);
     }
 
-    public static SeContainer startCdiContainer(Properties p, Class... beanClasses) {
+    public static SeContainer startCdiContainer(Map p, Class... beanClasses) {
         return startCdiContainer(p, new HashSet<>(Arrays.asList(beanClasses)));
     }
 
-    public static SeContainer startCdiContainer(Properties p, Set> beanClasses) {
+    public static SeContainer startCdiContainer(Map p, Set> beanClasses) {
         Config config = Config.builder()
                 .sources(ConfigSources.create(p))
                 .build();
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java
index 280bd06b0b5..a29d4d07af0 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java
@@ -24,6 +24,7 @@
 
 import java.util.Map;
 
+import static io.helidon.common.CollectionsHelper.mapOf;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class AdHocConfigBuilderTest {
@@ -39,7 +40,7 @@ class AdHocConfigBuilderTest {
 
     @Test
     void currentContext() {
-        Map propMap = CollectionsHelper.mapOf(
+        Map propMap = mapOf(
                 "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName()
         );
 
@@ -58,7 +59,7 @@ void currentContext() {
 
     @Test
     void customValueOverride() {
-        Map propMap = CollectionsHelper.mapOf(
+        Map propMap = mapOf(
                 "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG,
                 "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName()
         );
@@ -77,11 +78,11 @@ void customValueOverride() {
 
     @Test
     void putAllTest() {
-        Map propMap = CollectionsHelper.mapOf(
+        Map propMap = mapOf(
                 "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG
         );
 
-        Map propMap2 = CollectionsHelper.mapOf(
+        Map propMap2 = mapOf(
                 "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_1, ADDITION_ATTR_1_VALUE,
                 "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_2, ADDITION_ATTR_2_VALUE
         );
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
index 0524a56e453..dfea4734781 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
@@ -16,9 +16,7 @@
 
 package io.helidon.microprofile.messaging;
 
-import io.helidon.common.reactive.microprofile.HelidonReactiveStreamEngine;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -30,22 +28,29 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+//TODO: Move to reactive bridge module
 public class ReactiveEngineTest {
 
     @Test
-    void testTestHelidon() {
-        testEngine(new HelidonReactiveStreamEngine());
+    void multipleStages() {
+        // Create a stream of words
+        ReactiveStreams.of("hello", "from", "helidon", "reactive", "stream", "operators")
+                .map(String::toUpperCase) // Transform the words
+                .filter(s -> s.length() > 4) // Filter items
+                .forEach(word -> System.out.println(">> " + word)) // Terminal operation
+                .run(); // Run it (create the streams, subscribe to it...)
     }
 
-    private void testEngine(ReactiveStreamsEngine engine) {
+    @Test
+    void testTestHelidon() {
         Publisher publisher = ReactiveStreams.of("test1", "test2", "test3")
-                .buildRs(engine);
+                .buildRs();
         LatchSubscriber subscriber = new LatchSubscriber<>();
 
         ReactiveStreams
                 .fromPublisher(publisher)
                 .to(ReactiveStreams.fromSubscriber(subscriber))
-                .run(engine)
+                .run()
                 .toCompletableFuture();
         subscriber.assertNextCalled();
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java
deleted file mode 100644
index d78e72069a3..00000000000
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/Test.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package io.helidon.microprofile.messaging;
-
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-
-public class Test {
-    public static void main(String[] args) {
-        // Create a stream of words
-        ReactiveStreams.of("hello", "from", "smallrye", "reactive", "stream", "operators")
-                .map(String::toUpperCase) // Transform the words
-                .filter(s -> s.length() > 4) // Filter items
-                .forEach(word -> System.out.println(">> " + word)) // Terminal operation
-                .run(); // Run it (create the streams, subscribe to it...)
-    }
-}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedBean.java
new file mode 100644
index 00000000000..2016faefb34
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedBean.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+public class ConnectedBean {
+
+    public static final CountDownLatch LATCH = new CountDownLatch(IterableConnector.TEST_DATA.length);
+
+    @Incoming("iterable-channel-in")
+    public void receiveMethod(String msg) {
+        assertTrue(Arrays.asList(IterableConnector.TEST_DATA).contains(msg));
+        LATCH.countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedOnlyProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedOnlyProcessorBean.java
new file mode 100644
index 00000000000..28cbe0d6bb0
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedOnlyProcessorBean.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ConnectedOnlyProcessorBean {
+
+    @Incoming("iterable-channel-in")
+    @Outgoing("iterable-channel-out")
+    public String process(String msg) {
+        return msg;
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedProcessorBean.java
new file mode 100644
index 00000000000..331b7dea5a4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectedProcessorBean.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+public class ConnectedProcessorBean {
+
+    public static final CountDownLatch LATCH = new CountDownLatch(IterableConnector.TEST_DATA.length);
+    private static final Set PROCESSED_DATA =
+            Arrays.stream(IterableConnector.TEST_DATA)
+                    .map(ConnectedProcessorBean::reverseString)
+                    .collect(Collectors.toSet());
+
+    @Incoming("iterable-channel-in")
+    @Outgoing("inner-channel")
+    public String process(String msg) {
+        return reverseString(msg);
+    }
+
+    @Incoming("inner-channel")
+    public void receive(String msg) {
+        assertTrue(PROCESSED_DATA.contains(msg));
+        LATCH.countDown();
+    }
+
+    private static String reverseString(String msg) {
+        return new StringBuilder(msg).reverse().toString();
+    }
+
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
new file mode 100644
index 00000000000..0a57d773374
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import io.helidon.microprofile.messaging.AbstractCDITest;
+import org.junit.jupiter.api.Test;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static io.helidon.common.CollectionsHelper.mapOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ConnectorTest extends AbstractCDITest {
+
+    @Override
+    public void setUp() {
+        //Starting container manually
+    }
+
+    @Test
+    void connectorTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(
+                mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                IterableConnector.class,
+                ConnectedBean.class);
+        assertTrue(ConnectedBean.LATCH.await(2, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void connectorWithProcessorTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(
+                mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                IterableConnector.class,
+                ConnectedProcessorBean.class);
+        assertTrue(ConnectedProcessorBean.LATCH.await(2, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void connectorWithProcessorOnlyTest() throws InterruptedException {
+        Map p = mapOf(
+                "mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector",
+                "mp.messaging.outgoing.iterable-channel-out.connector", "iterable-connector");
+        cdiContainer = startCdiContainer(p, IterableConnector.class, ConnectedOnlyProcessorBean.class);
+        assertTrue(IterableConnector.LATCH.await(20, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void missingConnectorTest() {
+        assertThrows(DeploymentException.class, () ->
+                cdiContainer = startCdiContainer(
+                        mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                        ConnectedBean.class));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/IterableConnector.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/IterableConnector.java
new file mode 100644
index 00000000000..935492b4c2c
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/IterableConnector.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.spi.Connector;
+import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
+import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+@Connector("iterable-connector")
+public class IterableConnector implements IncomingConnectorFactory, OutgoingConnectorFactory {
+
+    public static final String[] TEST_DATA = {"test1", "test2", "test3"};
+    public static final CountDownLatch LATCH = new CountDownLatch(TEST_DATA.length);
+    private static final Set PROCESSED_DATA =
+            Arrays.stream(IterableConnector.TEST_DATA).collect(Collectors.toSet());
+
+    @Override
+    public PublisherBuilder> getPublisherBuilder(Config config) {
+        //TODO: use ReactiveStreams.of().map when engine is ready(supports more than one stage)
+        return ReactiveStreams.fromIterable(Arrays.stream(TEST_DATA).map(Message::of).collect(Collectors.toSet()));
+    }
+
+    @Override
+    public SubscriberBuilder, Void> getSubscriberBuilder(Config config) {
+        return ReactiveStreams.>builder().forEach(m -> {
+            assertTrue(PROCESSED_DATA.contains(m.getPayload()));
+            LATCH.countDown();
+        });
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
similarity index 67%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 9f21b3dc855..88393c269b2 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessagingCdiExtensionTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,25 +12,27 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.microprofile.messaging.beans.InnerProcessorBean;
-import io.helidon.microprofile.messaging.beans.InternalChannelsBean;
-import io.helidon.microprofile.messaging.beans.NotConnectedIncommingChannelBean;
-import io.helidon.microprofile.messaging.beans.NotConnectedOutgoingChannelBean;
+import io.helidon.microprofile.messaging.AbstractCDITest;
+import io.helidon.microprofile.messaging.inner.InnerProcessorBean;
+import io.helidon.microprofile.messaging.inner.InternalChannelsBean;
+import io.helidon.microprofile.messaging.inner.NotConnectedIncommingChannelBean;
+import io.helidon.microprofile.messaging.inner.NotConnectedOutgoingChannelBean;
 import org.junit.jupiter.api.Test;
 
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.util.Properties;
+import java.util.Collections;
 import java.util.concurrent.TimeUnit;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class MessagingCdiExtensionTest extends AbstractCDITest {
+public class InnerChannelTest extends AbstractCDITest {
 
     @Override
     public void setUp() {
@@ -39,8 +41,7 @@ public void setUp() {
 
     @Test
     void internalChannelsInSameBeanTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(new Properties(), InternalChannelsBean.class);
-
+        cdiContainer = startCdiContainer(Collections.emptyMap(), InternalChannelsBean.class);
         // Wait till all messages are delivered
         assertTrue(InternalChannelsBean.publisher_string_latch.await(2, TimeUnit.SECONDS)
                 , "All messages not delivered in time, number of unreceived messages: "
@@ -49,7 +50,7 @@ void internalChannelsInSameBeanTest() throws InterruptedException {
 
     @Test
     void processorInSameBeanTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(new Properties(), InnerProcessorBean.class);
+        cdiContainer = startCdiContainer(Collections.emptyMap(), InnerProcessorBean.class);
 
         // Wait till all messages are delivered
         assertTrue(InnerProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
@@ -60,12 +61,12 @@ void processorInSameBeanTest() throws InterruptedException {
     @Test
     void notConnectedIncomingChannelTest() {
         assertThrows(DeploymentException.class, () ->
-                cdiContainer = startCdiContainer(new Properties(), NotConnectedIncommingChannelBean.class));
+                cdiContainer = startCdiContainer(Collections.emptyMap(), NotConnectedIncommingChannelBean.class));
     }
 
     @Test
     void notConnectedOutgoingChannelTest() {
         assertThrows(DeploymentException.class, () ->
-                cdiContainer = startCdiContainer(new Properties(), NotConnectedOutgoingChannelBean.class));
+                cdiContainer = startCdiContainer(Collections.emptyMap(), NotConnectedOutgoingChannelBean.class));
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
similarity index 98%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
index 4a1513f467e..30cb7d72232 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InnerProcessorBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
@@ -29,7 +29,7 @@
  * limitations under the License.
  */
 
-package io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.common.reactive.Multi;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
index 447a6608596..ef25d0824d7 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/InternalChannelsBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.common.reactive.Multi;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
similarity index 94%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
index 7cc57fe966d..1db13ef3623 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedIncommingChannelBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.inner;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
similarity index 95%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
index a4b79f35754..1cf016c2ea9 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/NotConnectedOutgoingChannelBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.common.reactive.Multi;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
similarity index 73%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
index 15a1adb7f3b..ff46f0c8778 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/KafkaCdiExtensionTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,16 +12,18 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.kafka;
 
 import com.salesforce.kafka.test.junit5.SharedKafkaTestResource;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 import io.helidon.messaging.kafka.SimpleKafkaProducer;
 import io.helidon.messaging.kafka.connector.KafkaConnectorFactory;
-import io.helidon.microprofile.messaging.beans.KafkaConsumingBean;
+import io.helidon.microprofile.messaging.AbstractCDITest;
+import io.helidon.microprofile.messaging.kafka.KafkaConsumingBean;
 import org.apache.kafka.clients.producer.RecordMetadata;
 import org.apache.kafka.common.serialization.LongDeserializer;
 import org.apache.kafka.common.serialization.LongSerializer;
@@ -34,17 +36,18 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Properties;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
+import static io.helidon.common.CollectionsHelper.mapOf;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
-class KafkaCdiExtensionTest extends AbstractCDITest {
+public class KafkaCdiExtensionTest extends AbstractCDITest {
 
 
     @RegisterExtension
@@ -53,13 +56,13 @@ class KafkaCdiExtensionTest extends AbstractCDITest {
     public static final String TEST_MESSAGE = "this is first test message";
 
     @Override
-    protected void cdiConfig(Properties p) {
-        p.setProperty("mp.messaging.incoming.test-channel.connector", KafkaConnectorFactory.CONNECTOR_NAME);
-        p.setProperty("mp.messaging.incoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString());
-        p.setProperty("mp.messaging.incoming.test-channel.topic", TEST_TOPIC);
-        p.setProperty("mp.messaging.incoming.test-channel.key.deserializer", LongDeserializer.class.getName());
-        p.setProperty("mp.messaging.incoming.test-channel.value.deserializer", StringDeserializer.class.getName());
-
+    protected Map cdiConfig() {
+        return mapOf(
+                "mp.messaging.incoming.test-channel.connector", KafkaConnectorFactory.CONNECTOR_NAME,
+                "mp.messaging.incoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString(),
+                "mp.messaging.incoming.test-channel.topic", TEST_TOPIC,
+                "mp.messaging.incoming.test-channel.key.deserializer", LongDeserializer.class.getName(),
+                "mp.messaging.incoming.test-channel.value.deserializer", StringDeserializer.class.getName());
     }
 
     @Override
@@ -90,11 +93,12 @@ public void setUp() {
     @Test
     void incomingKafkaTest() throws InterruptedException {
         // Producer
-        Properties p = new Properties();
-        p.setProperty("mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString());
-        p.setProperty("mp.messaging.outcoming.test-channel.topic", TEST_TOPIC);
-        p.setProperty("mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName());
-        p.setProperty("mp.messaging.outcoming.test-channel.value.serializer", StringSerializer.class.getName());
+        Map p = mapOf(
+                "mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString(),
+                "mp.messaging.outcoming.test-channel.topic", TEST_TOPIC,
+                "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName(),
+                "mp.messaging.outcoming.test-channel.value.serializer", StringSerializer.class.getName()
+        );
 
         Config config = Config.builder()
                 .sources(ConfigSources.create(p))
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
index e2d8d694fbb..e1da09ef2f5 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaConsumingBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,9 +12,10 @@
  * 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 io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.kafka;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java
index 041c68f7a08..b8230483042 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/beans/KafkaProducingConsumingBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,9 +12,10 @@
  * 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 io.helidon.microprofile.messaging.beans;
+package io.helidon.microprofile.messaging.kafka;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 6d8e9e2f372..5195456202a 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -8,9 +8,13 @@
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 
 import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.function.BiConsumer;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
@@ -44,6 +48,66 @@ public  Publisher buildPublisher(Graph graph) throws UnsupportedStageExcep
 
     @Override
     public  SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException {
+        Collection stages = graph.getStages();
+        if (stages.size() != 1) {
+            //TODO: Support more than one stage
+            throw new RuntimeException("Exactly one stage is supported for now");
+        }
+        Stage firstStage = stages.iterator().next();
+        if (firstStage instanceof Stage.Collect) {
+            // Foreach
+            Stage.Collect collectStage = (Stage.Collect) firstStage;
+            CompletableFuture completableFuture = new CompletableFuture<>();
+            return new SubscriberWithCompletionStage() {
+                @Override
+                public CompletionStage getCompletion() {
+                    return completableFuture;
+                }
+
+                @Override
+                public Subscriber getSubscriber() {
+                    return new Subscriber() {
+
+                        private Subscription subscription;
+                        private Long chunkSize = 5L;
+                        private Long chunkPosition = 0L;
+
+                        @Override
+                        public void onSubscribe(Subscription s) {
+                            this.subscription = s;
+                            subscription.request(chunkSize);
+                        }
+
+                        @Override
+                        public void onNext(Object t) {
+                            BiConsumer accumulator = (BiConsumer) collectStage.getCollector().accumulator();
+                            accumulator.accept(null, t);
+                            accumulator.andThen((o, o2) -> {
+                                incrementAndCheckChunkPosition();
+                            });
+                        }
+
+                        @Override
+                        public void onError(Throwable t) {
+                            throw new RuntimeException(t);
+                        }
+
+                        @Override
+                        public void onComplete() {
+                            completableFuture.complete(null);
+                        }
+
+                        private void incrementAndCheckChunkPosition() {
+                            chunkPosition++;
+                            if (chunkPosition >= chunkSize) {
+                                chunkPosition = 0L;
+                                subscription.request(chunkSize);
+                            }
+                        }
+                    };
+                }
+            };
+        }
         throw new UnsupportedOperationException("Not implemented yet!!!");
     }
 
@@ -57,7 +121,9 @@ public  CompletionStage buildCompletion(Graph graph) throws UnsupportedSta
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
         CompletionStage completionStage = (CompletionStage) multiStagesCollector.toCompletableStage();
-        completionStage.exceptionally(t -> {throw new RuntimeException(t);});
+        completionStage.exceptionally(t -> {
+            throw new RuntimeException(t);
+        });
         return completionStage;
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory b/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory
deleted file mode 100644
index 8e4c3a64b7e..00000000000
--- a/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
-#
-# 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.
-#
-
-org.eclipse.microprofile.reactive.streams.operators.core.ReactiveStreamsFactoryImpl
\ No newline at end of file

From 175c2e7e9bccd4783ed1f2427e75cff94922dc10 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 8 Nov 2019 15:58:24 +0100
Subject: [PATCH 09/66] Passing 10/14 tck tests

Signed-off-by: Daniel Kec 
---
 .../microprofile/messaging/MessageUtils.java  |  2 +-
 .../messaging/MessagingCdiExtension.java      |  1 +
 .../AbstractChannel.java}                     | 17 ++++--
 .../{ => channel}/ChannelRouter.java          | 43 +++++++--------
 .../channel/IncomingConnectorChannel.java     | 22 ++++++++
 .../IncomingMethodChannel.java}               | 13 +++--
 .../channel/OutgoingConnectorChannel.java     | 22 ++++++++
 .../OutgoingMethodChannel.java}               | 26 +++++-----
 .../ProcessorMethodChannel.java}              | 24 +++++----
 .../{ => reactive}/InternalProcessor.java     | 20 ++++---
 .../{ => reactive}/InternalSubscriber.java    | 26 ++--------
 .../OutgoingConnectorProcessor.java}          |  9 ++--
 .../messaging/inner/InnerChannelTest.java     | 14 +++--
 .../inner/PrimitiveProcessorBean.java         | 52 +++++++++++++++++++
 14 files changed, 201 insertions(+), 90 deletions(-)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{AbstractChannelMethod.java => channel/AbstractChannel.java} (94%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ => channel}/ChannelRouter.java (74%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{IncomingChannelMethod.java => channel/IncomingMethodChannel.java} (93%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{OutgoingChannelMethod.java => channel/OutgoingMethodChannel.java} (83%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ProcessorChannelMethod.java => channel/ProcessorMethodChannel.java} (91%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ => reactive}/InternalProcessor.java (68%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ => reactive}/InternalSubscriber.java (72%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ConnectorDownstreamProcessor.java => reactive/OutgoingConnectorProcessor.java} (71%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
index 281a541b961..688bff3efc6 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -33,7 +33,7 @@ public static Object unwrap(Object value, Class type) {
             } else if (type.isInstance(value)) {
                 return type.cast(value);
             } else {
-                throw new RuntimeException("Type mismatch " + value.getClass() + "cant be cast to " + type);
+                return value;
             }
         }
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
index a828d739420..1d9fb7469ba 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
@@ -16,6 +16,7 @@
 
 package io.helidon.microprofile.messaging;
 
+import io.helidon.microprofile.messaging.channel.ChannelRouter;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.messaging.spi.Connector;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
similarity index 94%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
index 634d0eb1b70..38a08f2cff4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AbstractChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,9 +12,10 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -30,7 +31,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public abstract class AbstractChannelMethod {
+public abstract class AbstractChannel {
 
     protected String incomingChannelName;
     protected String outgoingChannelName;
@@ -46,7 +47,7 @@ public abstract class AbstractChannelMethod {
 
 
 
-    public AbstractChannelMethod(String incomingChannelName, String outgoingChannelName, Method method, ChannelRouter router) {
+    public AbstractChannel(String incomingChannelName, String outgoingChannelName, Method method, ChannelRouter router) {
         this.incomingChannelName = incomingChannelName;
         this.outgoingChannelName = outgoingChannelName;
         this.router = router;
@@ -63,6 +64,14 @@ public void init(BeanManager beanManager, Config config) {
         this.config = config;
     }
 
+    public Method getMethod() {
+        return method;
+    }
+
+    public Object getBeanInstance() {
+        return beanInstance;
+    }
+
     public void setDeclaringBean(Bean bean) {
         this.bean = bean;
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
similarity index 74%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
index 4b2528eed2b..8e5a3ff554f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ChannelRouter.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,9 +12,10 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
 import io.helidon.microprofile.config.MpConfig;
@@ -36,9 +37,9 @@
 import java.util.Map;
 
 public class ChannelRouter {
-    private List connectableBeanMethods = new ArrayList<>();
-    private Map> incomingSubscriberMap = new HashMap<>();
-    private Map> outgoingSubscriberMap = new HashMap<>();
+    private List connectableBeanMethods = new ArrayList<>();
+    private Map> incomingSubscriberMap = new HashMap<>();
+    private Map> outgoingSubscriberMap = new HashMap<>();
 
     private Map> incomingConnectorFactoryMap = new HashMap<>();
     private Map> outgoingConnectorFactoryMap = new HashMap<>();
@@ -54,8 +55,8 @@ public void connect(BeanManager beanManager) {
         //Needs to be initialized before connecting,
         // fast publishers would call onNext before all bean references are resolved
         connectableBeanMethods.forEach(m -> m.init(beanManager, config));
-        connectableBeanMethods.stream().filter(OutgoingChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
-        connectableBeanMethods.stream().filter(IncomingChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
+        connectableBeanMethods.stream().filter(OutgoingMethodChannel.class::isInstance).forEach(AbstractChannel::connect);
+        connectableBeanMethods.stream().filter(IncomingMethodChannel.class::isInstance).forEach(AbstractChannel::connect);
         connectableBeanMethods.stream().filter(m -> !m.connected).forEach(m -> {
             throw new DeploymentException("Channel " + m.incomingChannelName + "/" + m.outgoingChannelName
                     + " has no candidate to connect to method: " + m.method);
@@ -64,23 +65,23 @@ public void connect(BeanManager beanManager) {
     }
 
     void addIncomingMethod(AnnotatedMethod m) {
-        IncomingChannelMethod incomingChannelMethod = new IncomingChannelMethod(m, this);
-        incomingChannelMethod.validate();
-        String channelName = incomingChannelMethod.getIncomingChannelName();
-        getIncomingSubscribers(channelName).add(incomingChannelMethod);
-        connectableBeanMethods.add(incomingChannelMethod);
+        IncomingMethodChannel incomingMethodChannel = new IncomingMethodChannel(m, this);
+        incomingMethodChannel.validate();
+        String channelName = incomingMethodChannel.getIncomingChannelName();
+        getIncomingSubscribers(channelName).add(incomingMethodChannel);
+        connectableBeanMethods.add(incomingMethodChannel);
     }
 
     void addOutgoingMethod(AnnotatedMethod m) {
-        OutgoingChannelMethod outgoingChannelMethod = new OutgoingChannelMethod(m, this);
-        outgoingChannelMethod.validate();
-        String channelName = outgoingChannelMethod.getOutgoingChannelName();
-        getOutgoingSubscribers(channelName).add(outgoingChannelMethod);
-        connectableBeanMethods.add(outgoingChannelMethod);
+        OutgoingMethodChannel outgoingMethodChannel = new OutgoingMethodChannel(m, this);
+        outgoingMethodChannel.validate();
+        String channelName = outgoingMethodChannel.getOutgoingChannelName();
+        getOutgoingSubscribers(channelName).add(outgoingMethodChannel);
+        connectableBeanMethods.add(outgoingMethodChannel);
     }
 
     void addProcessorMethod(AnnotatedMethod m) {
-        ProcessorChannelMethod channelMethod = new ProcessorChannelMethod(m, this);
+        ProcessorMethodChannel channelMethod = new ProcessorMethodChannel(m, this);
         channelMethod.validate();
         getIncomingSubscribers(channelMethod.getIncomingChannelName()).add(channelMethod);
         getOutgoingSubscribers(channelMethod.getOutgoingChannelName()).add(channelMethod);
@@ -97,7 +98,7 @@ public void addMethod(AnnotatedMethod m) {
         }
     }
 
-    void addConnectorFactory(Bean bean) {
+    public void addConnectorFactory(Bean bean) {
         Class beanType = bean.getBeanClass();
         Connector annotation = beanType.getAnnotation(Connector.class);
         if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
@@ -108,11 +109,11 @@ void addConnectorFactory(Bean bean) {
         }
     }
 
-    public List getIncomingSubscribers(String channelName) {
+    public List getIncomingSubscribers(String channelName) {
         return getOrCreateList(channelName, incomingSubscriberMap);
     }
 
-    public List getOutgoingSubscribers(String channelName) {
+    public List getOutgoingSubscribers(String channelName) {
         return getOrCreateList(channelName, outgoingSubscriberMap);
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java
new file mode 100644
index 00000000000..3e55195e40c
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+public class IncomingConnectorChannel {
+    //TODO: Move connector logic here
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java
similarity index 93%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java
index ba187147ea1..caf584b4938 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/IncomingChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,12 +12,15 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.AdHocConfigBuilder;
+import io.helidon.microprofile.messaging.reactive.InternalSubscriber;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
@@ -38,14 +41,14 @@
  * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming}
  * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method
  */
-public class IncomingChannelMethod extends AbstractChannelMethod {
+public class IncomingMethodChannel extends AbstractChannel {
 
-    private static final Logger LOGGER = Logger.getLogger(IncomingChannelMethod.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(IncomingMethodChannel.class.getName());
 
     protected PublisherBuilder> publisherBuilder;
     private Subscriber subscriber;
 
-    public IncomingChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+    public IncomingMethodChannel(AnnotatedMethod method, ChannelRouter router) {
         super(method.getAnnotation(Incoming.class).value(), null, method.getJavaMember(), router);
         resolveSignatureType();
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
new file mode 100644
index 00000000000..9dc0207baa9
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+public class OutgoingConnectorChannel {
+    //TODO: Move connector logic here
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
similarity index 83%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
index badd7f14ef4..5e73b332b78 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/OutgoingChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,18 +12,18 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.AdHocConfigBuilder;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
 import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Publisher;
 
@@ -33,17 +33,17 @@
 import java.util.List;
 import java.util.logging.Logger;
 
-public class OutgoingChannelMethod extends AbstractChannelMethod {
+public class OutgoingMethodChannel extends AbstractChannel {
 
-    private static final Logger LOGGER = Logger.getLogger(OutgoingChannelMethod.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(OutgoingMethodChannel.class.getName());
 
     private SubscriberBuilder, Void> subscriberBuilder;
 
-    public OutgoingChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+    public OutgoingMethodChannel(AnnotatedMethod method, ChannelRouter router) {
         super(null, method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router);
     }
 
-    void validate() {
+    public void validate() {
         if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
             throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
                     + method.toString());
@@ -78,15 +78,15 @@ public void connect() {
             connected = true;
         } else {
             // Connect to Incoming methods with publisher
-            List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
-            if (incomingChannelMethods != null) {
-                for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
+            List incomingMethodChannels = getRouter().getIncomingSubscribers(getOutgoingChannelName());
+            if (incomingMethodChannels != null) {
+                for (IncomingMethodChannel s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
                     System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
 
                     Publisher publisher = getPublisher();
-                    if(s instanceof ProcessorChannelMethod){
+                    if(s instanceof ProcessorMethodChannel){
                         // Processors managing subscribing
-                        ((ProcessorChannelMethod)s).setPublisher(publisher);
+                        ((ProcessorMethodChannel)s).setPublisher(publisher);
                     }else{
                         // TODO: Move subscribing to Incoming methods to align with processors
                         publisher.subscribe(s.getSubscriber());
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
similarity index 91%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
index fc6b0cf7c5f..84d0403a45e 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ProcessorChannelMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,12 +12,16 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.AdHocConfigBuilder;
+import io.helidon.microprofile.messaging.reactive.OutgoingConnectorProcessor;
+import io.helidon.microprofile.messaging.reactive.InternalProcessor;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
@@ -38,15 +42,15 @@
 import java.util.concurrent.CompletionStage;
 import java.util.logging.Logger;
 
-public class ProcessorChannelMethod extends IncomingChannelMethod {
+public class ProcessorMethodChannel extends IncomingMethodChannel {
 
-    private static final Logger LOGGER = Logger.getLogger(ProcessorChannelMethod.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(ProcessorMethodChannel.class.getName());
 
     private SubscriberBuilder, Void> subscriberBuilder;
     private Processor processor;
     private Publisher publisher;
 
-    public ProcessorChannelMethod(AnnotatedMethod method, ChannelRouter router) {
+    public ProcessorMethodChannel(AnnotatedMethod method, ChannelRouter router) {
         super(method, router);
         super.outgoingChannelName =
                 method.getAnnotation(Outgoing.class).value();
@@ -66,7 +70,7 @@ public void init(BeanManager beanManager, Config config) {
     }
 
     @Override
-    void validate() {
+    public void validate() {
         super.validate();
         if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
             throw new DeploymentException("Missing channel name in annotation @Outgoing on method "
@@ -125,14 +129,14 @@ protected void connect() {
             subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
                     .getOutgoingConnectorFactory(outgoingConnectorName.get()), beanManager))
                     .getSubscriberBuilder(augmentedConfig);
-            processor = new ConnectorDownstreamProcessor(this);
+            processor = new OutgoingConnectorProcessor(this);
             processor.subscribe((Subscriber) subscriberBuilder.build());
             connected = true;
         } else {
             // Connect to downstream Incoming methods with publisher
-            List incomingChannelMethods = getRouter().getIncomingSubscribers(getOutgoingChannelName());
-            if (incomingChannelMethods != null) {
-                for (IncomingChannelMethod s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
+            List incomingMethodChannels = getRouter().getIncomingSubscribers(getOutgoingChannelName());
+            if (incomingMethodChannels != null) {
+                for (IncomingMethodChannel s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
                     System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
                     connected = true;
                     s.connected = true;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
similarity index 68%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
index d7dc88e3c16..e6f9ae67a92 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,24 +12,28 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.reactive;
 
+import io.helidon.microprofile.messaging.MessageUtils;
+import io.helidon.microprofile.messaging.channel.ProcessorMethodChannel;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 
 public class InternalProcessor implements Processor {
 
 
-    private ProcessorChannelMethod processorChannelMethod;
+    private ProcessorMethodChannel processorMethodChannel;
     private Subscriber subscriber;
 
-    public InternalProcessor(ProcessorChannelMethod processorChannelMethod) {
-        this.processorChannelMethod = processorChannelMethod;
+    public InternalProcessor(ProcessorMethodChannel processorMethodChannel) {
+        this.processorMethodChannel = processorMethodChannel;
     }
 
     @Override
@@ -46,8 +50,10 @@ public void onSubscribe(Subscription s) {
     public void onNext(Object incomingValue) {
         try {
             //TODO: Has to be always one param in the processor, validate and propagate better
-            Class paramType = processorChannelMethod.method.getParameterTypes()[0];
-            Object processedValue = processorChannelMethod.method.invoke(processorChannelMethod.beanInstance, MessageUtils.unwrap(incomingValue, paramType));
+            Method method = processorMethodChannel.getMethod();
+            Class paramType = method.getParameterTypes()[0];
+            Object processedValue = method.invoke(processorMethodChannel.getBeanInstance(),
+                    MessageUtils.unwrap(incomingValue, paramType));
             subscriber.onNext(wrapValue(processedValue));
         } catch (IllegalAccessException | InvocationTargetException e) {
             subscriber.onError(e);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
similarity index 72%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
index 6786ad4da90..91569198a57 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,13 +12,14 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.reactive;
 
 import io.helidon.common.context.Context;
 import io.helidon.common.context.Contexts;
-import org.eclipse.microprofile.reactive.messaging.Message;
+import io.helidon.microprofile.messaging.MessageUtils;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
@@ -48,32 +49,15 @@ public void onSubscribe(Subscription s) {
     @Override
     public void onNext(Object message) {
         try {
-            final Object paramValue;
             Class paramType = this.method.getParameterTypes()[0];
 
-            if (paramType != Message.class && !(message instanceof Message)) {
-                paramValue = paramType.cast(message);
-
-            } else if (paramType == Message.class && message instanceof Message) {
-                paramValue = paramType.cast(message);
-
-            } else if (paramType != Message.class && message instanceof Message) {
-                paramValue = paramType.cast(((Message) message).getPayload());
-
-            } else if (paramType == Message.class && !(message instanceof Message)) {
-                paramValue = paramType.cast(Message.of(message));
-
-            } else {
-                paramValue = message;
-            }
-
             Context parentContext = Context.create();
             Context context = Context
                     .builder()
                     .parent(parentContext)
                     .id(parentContext.id() + ":message-" + UUID.randomUUID().toString())
                     .build();
-            Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, paramValue));
+            Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, MessageUtils.unwrap(message, paramType)));
             incrementAndCheckChunkPosition();
         } catch (Exception e) {
             //Notify publisher to stop sending
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java
similarity index 71%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java
index 3fcb81aac3f..5c1ba9b9c5f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/ConnectorDownstreamProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java
@@ -15,14 +15,15 @@
  *
  */
 
-package io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.reactive;
 
+import io.helidon.microprofile.messaging.channel.ProcessorMethodChannel;
 import org.eclipse.microprofile.reactive.messaging.Message;
 
-public class ConnectorDownstreamProcessor extends InternalProcessor {
+public class OutgoingConnectorProcessor extends InternalProcessor {
 
-    public ConnectorDownstreamProcessor(ProcessorChannelMethod processorChannelMethod) {
-        super(processorChannelMethod);
+    public OutgoingConnectorProcessor(ProcessorMethodChannel processorMethodChannel) {
+        super(processorMethodChannel);
     }
 
     @Override
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 88393c269b2..7867927be32 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -18,10 +18,6 @@
 package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.microprofile.messaging.AbstractCDITest;
-import io.helidon.microprofile.messaging.inner.InnerProcessorBean;
-import io.helidon.microprofile.messaging.inner.InternalChannelsBean;
-import io.helidon.microprofile.messaging.inner.NotConnectedIncommingChannelBean;
-import io.helidon.microprofile.messaging.inner.NotConnectedOutgoingChannelBean;
 import org.junit.jupiter.api.Test;
 
 import javax.enterprise.inject.spi.DeploymentException;
@@ -58,6 +54,16 @@ void processorInSameBeanTest() throws InterruptedException {
                         + InnerProcessorBean.testLatch.getCount());
     }
 
+    @Test
+    void primitiveProcessorTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(Collections.emptyMap(), PrimitiveProcessorBean.class);
+
+        // Wait till all messages are delivered
+        assertTrue(PrimitiveProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
+                , "All messages not delivered in time, number of unreceived messages: "
+                        + PrimitiveProcessorBean.testLatch.getCount());
+    }
+
     @Test
     void notConnectedIncomingChannelTest() {
         assertThrows(DeploymentException.class, () ->
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
new file mode 100644
index 00000000000..2632ee28016
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+@ApplicationScoped
+public class PrimitiveProcessorBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("inner-processor")
+    public Publisher produceMessage() {
+        return Multi.justMP(IntStream.range(0, 10).boxed().collect(Collectors.toList()));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public int process(int i) {
+        return i++;
+    }
+
+    @Incoming("inner-consumer")
+    public void receiveMessage(int i) {
+        testLatch.countDown();
+    }
+
+}

From 5b9c71411b7fd10dbad9294556372ba4507a2681 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sun, 10 Nov 2019 21:48:19 +0100
Subject: [PATCH 10/66] Major refactor

Signed-off-by: Daniel Kec 
---
 .../microprofile/messaging/MessageUtils.java  |   6 +-
 .../messaging/channel/AbstractChannel.java    |  60 +-----
 .../messaging/channel/ChannelRouter.java      | 136 ++++++++-----
 ...MethodChannel.java => IncomingMethod.java} |  44 +----
 .../channel/OutgoingConnectorChannel.java     |  22 ---
 .../messaging/channel/OutgoingMethod.java     |  76 ++++++++
 .../channel/OutgoingMethodChannel.java        | 101 ----------
 .../messaging/channel/ProcessorMethod.java    | 129 +++++++++++++
 .../channel/ProcessorMethodChannel.java       | 181 ------------------
 .../messaging/channel/UniversalChannel.java   | 131 +++++++++++++
 .../connector/ConfigurableConnector.java      |  60 ++++++
 .../connector/IncomingConnector.java          |  64 +++++++
 .../connector/OutgoingConnector.java          |  70 +++++++
 .../PublishingConnector.java}                 |  23 +--
 .../SubscribingConnector.java}                |  15 +-
 .../messaging/reactive/InternalProcessor.java |  15 +-
 .../messaging/reactive/InternalPublisher.java |  46 +++++
 .../messaging/reactive/ProxyProcessor.java    |  77 ++++++++
 .../messaging/connector/ConnectorTest.java    |   2 +-
 .../messaging/inner/InnerChannelTest.java     |  22 +++
 .../inner/MultipleProcessorBean.java          |  63 ++++++
 .../inner/MultipleTypeProcessorChainBean.java |  64 +++++++
 .../kafka/KafkaCdiExtensionTest.java          |  22 ++-
 .../messaging/kafka/KafkaConsumingBean.java   |   4 +-
 .../reactive/HelidonReactiveStreamEngine.java |  38 ++--
 25 files changed, 981 insertions(+), 490 deletions(-)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/{IncomingMethodChannel.java => IncomingMethod.java} (63%)
 delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
 delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
 delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive/OutgoingConnectorProcessor.java => connector/PublishingConnector.java} (58%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{channel/IncomingConnectorChannel.java => connector/SubscribingConnector.java} (63%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
index 688bff3efc6..59115981bcf 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -23,15 +23,15 @@ public class MessageUtils {
     public static Object unwrap(Object value, Class type) {
         if (type.equals(Message.class)) {
             if (value instanceof Message) {
-                return type.cast(value);
+                return value;
             } else {
                 return Message.of(value);
             }
         } else {
             if (value instanceof Message) {
-                return type.cast(((Message) value).getPayload());
+                return ((Message) value).getPayload();
             } else if (type.isInstance(value)) {
-                return type.cast(value);
+                return value;
             } else {
                 return value;
             }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
index 38a08f2cff4..48df7bd472a 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
@@ -18,17 +18,12 @@
 package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.reactivestreams.Publisher;
 
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 public abstract class AbstractChannel {
@@ -46,18 +41,13 @@ public abstract class AbstractChannel {
     public boolean connected = false;
 
 
-
-    public AbstractChannel(String incomingChannelName, String outgoingChannelName, Method method, ChannelRouter router) {
-        this.incomingChannelName = incomingChannelName;
-        this.outgoingChannelName = outgoingChannelName;
+    public AbstractChannel(Method method, ChannelRouter router) {
         this.router = router;
         this.method = method;
     }
 
     abstract void validate();
 
-    protected abstract void connect();
-
     public void init(BeanManager beanManager, Config config) {
         this.beanInstance = getBeanInstance(bean, beanManager);
         this.beanManager = beanManager;
@@ -88,53 +78,15 @@ public String getOutgoingChannelName() {
         return outgoingChannelName;
     }
 
-    protected PublisherBuilder getPublisherBuilder() {
-        try {
-            Object returnInstance = method.invoke(beanInstance);
-            if (returnInstance instanceof Publisher) {
-                // Called once at assembly time.
-                return ReactiveStreams.fromPublisher((Publisher) returnInstance);
-            } else if (returnInstance instanceof PublisherBuilder) {
-                // Called once at assembly time.
-                return (PublisherBuilder) returnInstance;
-            } else if (returnInstance instanceof Message) {
-                //TODO: Supported method signatures in the spec - Message !!!
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            } else {
-                //TODO: Supported method signatures in the spec - Any type
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            }
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e);
-        }
+    public Type getType() {
+        return type;
     }
 
-    protected Publisher getPublisher() {
-        try {
-            Object returnInstance = method.invoke(beanInstance);
-            if (returnInstance instanceof Publisher) {
-                // Called once at assembly time.
-                return (Publisher) returnInstance;
-            } else if (returnInstance instanceof PublisherBuilder) {
-                // Called once at assembly time.
-                return ((PublisherBuilder) returnInstance).buildRs();
-            } else if (returnInstance instanceof Message) {
-                //TODO: Supported method signatures in the spec - Message !!!
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            } else {
-                //TODO: Supported method signatures in the spec - Any type
-                // Called for each request made by the subscriber
-                throw new UnsupportedOperationException("Not implemented yet!!");
-            }
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e);
-        }
+    public void setType(Type type) {
+        this.type = type;
     }
 
-    protected Object getBeanInstance(Bean bean, BeanManager beanManager) {
+    public static Object getBeanInstance(Bean bean, BeanManager beanManager) {
         javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope());
         Object instance = context.get(bean);
         if (instance == null) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
index 8e5a3ff554f..c573db09408 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
@@ -19,6 +19,8 @@
 
 import io.helidon.config.Config;
 import io.helidon.microprofile.config.MpConfig;
+import io.helidon.microprofile.messaging.connector.IncomingConnector;
+import io.helidon.microprofile.messaging.connector.OutgoingConnector;
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -26,6 +28,7 @@
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
 
+import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
@@ -35,14 +38,20 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 public class ChannelRouter {
+    private Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig();
+
     private List connectableBeanMethods = new ArrayList<>();
-    private Map> incomingSubscriberMap = new HashMap<>();
-    private Map> outgoingSubscriberMap = new HashMap<>();
 
-    private Map> incomingConnectorFactoryMap = new HashMap<>();
-    private Map> outgoingConnectorFactoryMap = new HashMap<>();
+    private Map channelMap = new HashMap<>();
+    private Map incomingConnectorMap = new HashMap<>();
+    private Map outgoingConnectorMap = new HashMap<>();
+
+    private List> incomingConnectorFactoryList = new ArrayList<>();
+    private List> outgoingConnectorFactoryList = new ArrayList<>();
+    private BeanManager beanManager;
 
     public void registerBeanReference(Bean bean) {
         connectableBeanMethods.stream()
@@ -51,40 +60,69 @@ public void registerBeanReference(Bean bean) {
     }
 
     public void connect(BeanManager beanManager) {
-        Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig();
+        this.beanManager = beanManager;
         //Needs to be initialized before connecting,
         // fast publishers would call onNext before all bean references are resolved
+        incomingConnectorFactoryList.forEach(this::addOutgoingConnector);
+        outgoingConnectorFactoryList.forEach(this::addIncomingConnector);
         connectableBeanMethods.forEach(m -> m.init(beanManager, config));
-        connectableBeanMethods.stream().filter(OutgoingMethodChannel.class::isInstance).forEach(AbstractChannel::connect);
-        connectableBeanMethods.stream().filter(IncomingMethodChannel.class::isInstance).forEach(AbstractChannel::connect);
-        connectableBeanMethods.stream().filter(m -> !m.connected).forEach(m -> {
-            throw new DeploymentException("Channel " + m.incomingChannelName + "/" + m.outgoingChannelName
-                    + " has no candidate to connect to method: " + m.method);
-        });
-//        connectableBeanMethods.stream().filter(ProcessorChannelMethod.class::isInstance).forEach(AbstractChannelMethod::connect);
+
+
+        channelMap.values().forEach(UniversalChannel::findConnectors);
+        channelMap.values().stream().filter(UniversalChannel::isLastInChain).forEach(UniversalChannel::connect);
+    }
+
+    private void addIncomingConnector(Bean bean) {
+        OutgoingConnectorFactory outgoingConnectorFactory = lookup(bean, beanManager);
+        String connectorName = bean.getBeanClass().getAnnotation(Connector.class).value();
+        IncomingConnector incomingConnector = new IncomingConnector(connectorName, outgoingConnectorFactory, this);
+        incomingConnectorMap.put(connectorName, incomingConnector);
     }
 
-    void addIncomingMethod(AnnotatedMethod m) {
-        IncomingMethodChannel incomingMethodChannel = new IncomingMethodChannel(m, this);
-        incomingMethodChannel.validate();
-        String channelName = incomingMethodChannel.getIncomingChannelName();
-        getIncomingSubscribers(channelName).add(incomingMethodChannel);
-        connectableBeanMethods.add(incomingMethodChannel);
+    private void addOutgoingConnector(Bean bean) {
+        IncomingConnectorFactory incomingConnectorFactory = lookup(bean, beanManager);
+        String connectorName = bean.getBeanClass().getAnnotation(Connector.class).value();
+        OutgoingConnector outgoingConnector = new OutgoingConnector(connectorName, incomingConnectorFactory, this);
+        outgoingConnectorMap.put(connectorName, outgoingConnector);
+    }
+
+    private void addIncomingMethod(AnnotatedMethod m) {
+        IncomingMethod incomingMethod = new IncomingMethod(m, this);
+        incomingMethod.validate();
+
+        String channelName = incomingMethod.getIncomingChannelName();
+
+        UniversalChannel universalChannel = getOrCreateChannel(channelName);
+        universalChannel.setIncoming(incomingMethod);
+
+        connectableBeanMethods.add(incomingMethod);
     }
 
-    void addOutgoingMethod(AnnotatedMethod m) {
-        OutgoingMethodChannel outgoingMethodChannel = new OutgoingMethodChannel(m, this);
-        outgoingMethodChannel.validate();
-        String channelName = outgoingMethodChannel.getOutgoingChannelName();
-        getOutgoingSubscribers(channelName).add(outgoingMethodChannel);
-        connectableBeanMethods.add(outgoingMethodChannel);
+    private void addOutgoingMethod(AnnotatedMethod m) {
+        OutgoingMethod outgoingMethod = new OutgoingMethod(m, this);
+        outgoingMethod.validate();
+
+        String channelName = outgoingMethod.getOutgoingChannelName();
+
+        UniversalChannel universalChannel = getOrCreateChannel(channelName);
+        universalChannel.setOutgoing(outgoingMethod);
+
+        connectableBeanMethods.add(outgoingMethod);
     }
 
-    void addProcessorMethod(AnnotatedMethod m) {
-        ProcessorMethodChannel channelMethod = new ProcessorMethodChannel(m, this);
+    private void addProcessorMethod(AnnotatedMethod m) {
+        ProcessorMethod channelMethod = new ProcessorMethod(m, this);
         channelMethod.validate();
-        getIncomingSubscribers(channelMethod.getIncomingChannelName()).add(channelMethod);
-        getOutgoingSubscribers(channelMethod.getOutgoingChannelName()).add(channelMethod);
+
+        String incomingChannelName = channelMethod.getIncomingChannelName();
+        String outgoingChannelName = channelMethod.getOutgoingChannelName();
+
+        UniversalChannel incomingUniversalChannel = getOrCreateChannel(incomingChannelName);
+        incomingUniversalChannel.setIncoming(channelMethod);
+
+        UniversalChannel outgoingUniversalChannel = getOrCreateChannel(outgoingChannelName);
+        outgoingUniversalChannel.setOutgoing(channelMethod);
+
         connectableBeanMethods.add(channelMethod);
     }
 
@@ -102,34 +140,44 @@ public void addConnectorFactory(Bean bean) {
         Class beanType = bean.getBeanClass();
         Connector annotation = beanType.getAnnotation(Connector.class);
         if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
-            incomingConnectorFactoryMap.put(annotation.value(), bean);
+            incomingConnectorFactoryList.add(bean);
         }
         if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
-            outgoingConnectorFactoryMap.put(annotation.value(), bean);
+            outgoingConnectorFactoryList.add(bean);
         }
     }
 
-    public List getIncomingSubscribers(String channelName) {
-        return getOrCreateList(channelName, incomingSubscriberMap);
+    public Optional getIncomingConnector(String connectorName) {
+        return Optional.ofNullable(incomingConnectorMap.get(connectorName));
     }
 
-    public List getOutgoingSubscribers(String channelName) {
-        return getOrCreateList(channelName, outgoingSubscriberMap);
+    public Optional getOutgoingConnector(String connectorName) {
+        return Optional.ofNullable(outgoingConnectorMap.get(connectorName));
     }
 
-    private static  List getOrCreateList(String key, Map> map) {
-        List list = map.getOrDefault(key, new ArrayList<>());
-        if (list.isEmpty()) {
-            map.put(key, list);
-        }
-        return list;
+    public Config getConfig() {
+        return config;
     }
 
-    public Bean getIncomingConnectorFactory(String connectorName) {
-        return incomingConnectorFactoryMap.get(connectorName);
+    private UniversalChannel getOrCreateChannel(String channelName) {
+        UniversalChannel universalChannel = channelMap.get(channelName);
+        if (universalChannel == null) {
+            universalChannel = new UniversalChannel(this);
+            channelMap.put(channelName, universalChannel);
+        }
+        return universalChannel;
     }
 
-    public Bean getOutgoingConnectorFactory(String connectorName) {
-        return outgoingConnectorFactoryMap.get(connectorName);
+    public static  T lookup(Bean bean, BeanManager beanManager) {
+        javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope());
+        Object instance = context.get(bean);
+        if (instance == null) {
+            CreationalContext creationalContext = beanManager.createCreationalContext(bean);
+            instance = beanManager.getReference(bean, bean.getBeanClass(), creationalContext);
+        }
+        if (instance == null) {
+            throw new DeploymentException("Instance of bean " + bean.getName() + " not found");
+        }
+        return (T) instance;
     }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
similarity index 63%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index caf584b4938..b603c036c85 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethodChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -18,14 +18,8 @@
 package io.helidon.microprofile.messaging.channel;
 
 import io.helidon.config.Config;
-import io.helidon.config.ConfigValue;
-import io.helidon.microprofile.messaging.AdHocConfigBuilder;
 import io.helidon.microprofile.messaging.reactive.InternalSubscriber;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
-import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Subscriber;
 
@@ -41,15 +35,15 @@
  * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming}
  * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method
  */
-public class IncomingMethodChannel extends AbstractChannel {
+public class IncomingMethod extends AbstractChannel {
 
-    private static final Logger LOGGER = Logger.getLogger(IncomingMethodChannel.class.getName());
+    private static final Logger LOGGER = Logger.getLogger(IncomingMethod.class.getName());
 
-    protected PublisherBuilder> publisherBuilder;
     private Subscriber subscriber;
 
-    public IncomingMethodChannel(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getAnnotation(Incoming.class).value(), null, method.getJavaMember(), router);
+    public IncomingMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(method.getJavaMember(), router);
+        super.incomingChannelName = method.getAnnotation(Incoming.class).value();
         resolveSignatureType();
     }
 
@@ -85,34 +79,6 @@ public void init(BeanManager beanManager, Config config) {
         }
     }
 
-    @Override
-    protected void connect() {
-        Config channelConfig = config.get("mp.messaging.incoming").get(incomingChannelName);
-        ConfigValue connectorName = channelConfig.get("connector").asString();
-        if (connectorName.isPresent()) {
-            Config connectorConfig = config.get("mp.messaging.connector")
-                    .get(connectorName.get());
-            org.eclipse.microprofile.config.Config augmentedConfig =
-                    AdHocConfigBuilder
-                            .from(channelConfig)
-                            //It seams useless but its required by the spec
-                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, incomingChannelName)
-                            .putAll(connectorConfig)
-                            .build();
-            publisherBuilder =
-                    ((IncomingConnectorFactory) getBeanInstance(
-                            getRouter().getIncomingConnectorFactory(connectorName.get()),
-                            beanManager))
-                            .getPublisherBuilder(augmentedConfig);
-
-            //TODO: iterate over multiple publishers / does spec even support multiple publishers?
-            publisherBuilder.buildRs().subscribe(this.subscriber);
-            LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", incomingChannelName, connectorName.get(), method.toString()));
-            connected = true;
-        }
-
-    }
-
     public Subscriber getSubscriber() {
         return subscriber;
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
deleted file mode 100644
index 9dc0207baa9..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingConnectorChannel.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging.channel;
-
-public class OutgoingConnectorChannel {
-    //TODO: Move connector logic here
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
new file mode 100644
index 00000000000..e9d0bb1c5e6
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import io.helidon.config.Config;
+import io.helidon.microprofile.messaging.reactive.InternalPublisher;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.logging.Logger;
+
+public class OutgoingMethod extends AbstractChannel {
+
+    private static final Logger LOGGER = Logger.getLogger(OutgoingMethod.class.getName());
+
+    private Publisher publisher;
+
+    public OutgoingMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(method.getJavaMember(), router);
+        super.outgoingChannelName = method.getAnnotation(Outgoing.class).value();
+    }
+
+    @Override
+    public void init(BeanManager beanManager, Config config) {
+        super.init(beanManager, config);
+        // TODO: Rewrite with enum
+        try {
+            Class returnType = method.getReturnType();
+            if (returnType.equals(Publisher.class)) {
+                publisher = (Publisher) method.invoke(beanInstance);
+            } else if (returnType.equals(PublisherBuilder.class)) {
+                publisher = ((PublisherBuilder) method.invoke(beanInstance)).buildRs();
+            } else {
+                publisher = new InternalPublisher(method, beanInstance);
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void validate() {
+        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
+            throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
+                    + method.toString());
+        }
+        if (method.getReturnType().equals(Void.TYPE)) {
+            throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: "
+                    + method.toString());
+        }
+    }
+
+    public Publisher getPublisher() {
+        return publisher;
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
deleted file mode 100644
index 5e73b332b78..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethodChannel.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging.channel;
-
-import io.helidon.config.Config;
-import io.helidon.config.ConfigValue;
-import io.helidon.microprofile.messaging.AdHocConfigBuilder;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
-import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.reactivestreams.Publisher;
-
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.util.List;
-import java.util.logging.Logger;
-
-public class OutgoingMethodChannel extends AbstractChannel {
-
-    private static final Logger LOGGER = Logger.getLogger(OutgoingMethodChannel.class.getName());
-
-    private SubscriberBuilder, Void> subscriberBuilder;
-
-    public OutgoingMethodChannel(AnnotatedMethod method, ChannelRouter router) {
-        super(null, method.getAnnotation(Outgoing.class).value(), method.getJavaMember(), router);
-    }
-
-    public void validate() {
-        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
-                    + method.toString());
-        }
-        if (method.getReturnType().equals(Void.TYPE)) {
-            throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: "
-                    + method.toString());
-        }
-    }
-
-    public void connect() {
-        Config channelConfig = config.get("mp.messaging.outgoing").get(outgoingChannelName);
-        ConfigValue connectorName = channelConfig.get("connector").asString();
-        if (connectorName.isPresent()) {
-            //Connect to connector
-            Config connectorConfig = config
-                    .get("mp.messaging.connector")
-                    .get(connectorName.get());
-            org.eclipse.microprofile.config.Config augmentedConfig =
-                    AdHocConfigBuilder
-                            .from(channelConfig)
-                            //It seams useless but its required by the spec
-                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, outgoingChannelName)
-                            .putAll(connectorConfig)
-                            .build();
-            subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
-                    .getOutgoingConnectorFactory(connectorName.get()), beanManager))
-                    .getSubscriberBuilder(augmentedConfig);
-            getPublisherBuilder()
-                    .buildRs()
-                    .subscribe(subscriberBuilder.build());
-            connected = true;
-        } else {
-            // Connect to Incoming methods with publisher
-            List incomingMethodChannels = getRouter().getIncomingSubscribers(getOutgoingChannelName());
-            if (incomingMethodChannels != null) {
-                for (IncomingMethodChannel s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
-                    System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
-
-                    Publisher publisher = getPublisher();
-                    if(s instanceof ProcessorMethodChannel){
-                        // Processors managing subscribing
-                        ((ProcessorMethodChannel)s).setPublisher(publisher);
-                    }else{
-                        // TODO: Move subscribing to Incoming methods to align with processors
-                        publisher.subscribe(s.getSubscriber());
-                    }
-                    s.connected = true;
-                    connected = true;
-                }
-            }
-
-        }
-    }
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
new file mode 100644
index 00000000000..d0535a51a5a
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import io.helidon.config.Config;
+import io.helidon.microprofile.messaging.reactive.InternalProcessor;
+import io.helidon.microprofile.messaging.reactive.ProxyProcessor;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.concurrent.CompletionStage;
+import java.util.logging.Logger;
+
+public class ProcessorMethod extends AbstractChannel {
+
+    private static final Logger LOGGER = Logger.getLogger(ProcessorMethod.class.getName());
+
+    private Processor processor;
+    private UniversalChannel incomingChannel;
+    private UniversalChannel outgoingChannel;
+
+    public ProcessorMethod(AnnotatedMethod method, ChannelRouter router) {
+        super(method.getJavaMember(), router);
+        super.incomingChannelName =
+                method.getAnnotation(Incoming.class).value();
+        super.outgoingChannelName =
+                method.getAnnotation(Outgoing.class).value();
+        resolveSignatureType();
+    }
+
+    @Override
+    public void init(BeanManager beanManager, Config config) {
+        super.init(beanManager, config);
+        if (type.isInvokeAtAssembly()) {
+            // TODO: Incoming methods returning custom processor
+            processor = new ProxyProcessor(this);
+        } else {
+            // Create brand new subscriber
+            processor = new InternalProcessor(this);
+        }
+    }
+
+    @Override
+    public void validate() {
+        if (incomingChannelName == null || incomingChannelName.trim().isEmpty()) {
+            throw new DeploymentException("Missing channel name in annotation @Incoming on method "
+                    + method.toString());
+        }
+        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
+            throw new DeploymentException("Missing channel name in annotation @Outgoing on method "
+                    + method.toString());
+        }
+        if (this.method.getParameterTypes().length > 1) {
+            throw new DeploymentException("Bad processor method signature, "
+                    + "wrong number of parameters, only one or none allowed."
+                    + method.toString());
+        }
+    }
+
+    public Processor getProcessor() {
+        return processor;
+    }
+
+    public UniversalChannel getIncomingChannel() {
+        return incomingChannel;
+    }
+
+    public void setIncomingChannel(UniversalChannel incomingChannel) {
+        this.incomingChannel = incomingChannel;
+    }
+
+    public UniversalChannel getOutgoingChannel() {
+        return outgoingChannel;
+    }
+
+    public void setOutgoingChannel(UniversalChannel outgoingChannel) {
+        this.outgoingChannel = outgoingChannel;
+    }
+
+    private void resolveSignatureType() {
+        Class returnType = this.method.getReturnType();
+        Class parameterType = this.method.getParameterTypes()[0];
+        if (Void.TYPE.equals(parameterType)) {
+            if (Processor.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_VOID_2_PROCESSOR;
+            } else if (ProcessorBuilder.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER;
+            } else {
+                throw new DeploymentException("Bad processor method signature " + method);
+            }
+        } else if (Publisher.class.equals(parameterType) && Publisher.class.equals(returnType)) {
+            this.type = Type.PROCESSOR_PUBLISHER_2_PUBLISHER;
+        } else if (PublisherBuilder.class.equals(parameterType) && PublisherBuilder.class.equals(returnType)) {
+            this.type = Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER;
+        } else {
+            if (Publisher.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_MSG_2_PUBLISHER;
+            } else if (CompletionStage.class.equals(returnType)) {
+                this.type = Type.PROCESSOR_MSG_2_COMPL_STAGE;
+            } else {
+                this.type = Type.PROCESSOR_MSG_2_MSG;
+            }
+        }
+    }
+
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
deleted file mode 100644
index 84d0403a45e..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethodChannel.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging.channel;
-
-import io.helidon.config.Config;
-import io.helidon.config.ConfigValue;
-import io.helidon.microprofile.messaging.AdHocConfigBuilder;
-import io.helidon.microprofile.messaging.reactive.OutgoingConnectorProcessor;
-import io.helidon.microprofile.messaging.reactive.InternalProcessor;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
-import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
-import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
-import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.util.List;
-import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
-
-public class ProcessorMethodChannel extends IncomingMethodChannel {
-
-    private static final Logger LOGGER = Logger.getLogger(ProcessorMethodChannel.class.getName());
-
-    private SubscriberBuilder, Void> subscriberBuilder;
-    private Processor processor;
-    private Publisher publisher;
-
-    public ProcessorMethodChannel(AnnotatedMethod method, ChannelRouter router) {
-        super(method, router);
-        super.outgoingChannelName =
-                method.getAnnotation(Outgoing.class).value();
-        resolveSignatureType();
-    }
-
-    @Override
-    public void init(BeanManager beanManager, Config config) {
-        super.init(beanManager, config);
-        if (type.isInvokeAtAssembly()) {
-            // TODO: Incoming methods returning custom processor
-            throw new UnsupportedOperationException("Not implemented yet!");
-        } else {
-            // Create brand new subscriber
-            processor = new InternalProcessor(this);
-        }
-    }
-
-    @Override
-    public void validate() {
-        super.validate();
-        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Outgoing on method "
-                    + method.toString());
-        }
-        if (this.method.getParameterTypes().length > 1) {
-            throw new DeploymentException("Bad processor method signature, "
-                    + "wrong number of parameters, only one or none allowed."
-                    + method.toString());
-        }
-    }
-
-    @Override
-    protected void connect() {
-        //TODO: Extract connectors to UpstreamConnectorChannel and DownstreamConnectorChannel also rename channelMethods to channels only
-        //Connect to upstream incoming connector if any
-        Config incomingChannelConfig = config.get("mp.messaging.incoming").get(incomingChannelName);
-        ConfigValue connectorName = incomingChannelConfig.get("connector").asString();
-        if (connectorName.isPresent()) {
-            Config connectorConfig = config.get("mp.messaging.connector")
-                    .get(connectorName.get());
-            org.eclipse.microprofile.config.Config augmentedConfig =
-                    AdHocConfigBuilder
-                            .from(incomingChannelConfig)
-                            //It seams useless but its required by the spec
-                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, incomingChannelName)
-                            .putAll(connectorConfig)
-                            .build();
-            publisherBuilder =
-                    ((IncomingConnectorFactory) getBeanInstance(
-                            getRouter().getIncomingConnectorFactory(connectorName.get()),
-                            beanManager))
-                            .getPublisherBuilder(augmentedConfig);
-
-            //TODO: iterate over multiple publishers / does spec even support multiple publishers?
-            publisher = (Publisher) publisherBuilder.buildRs();
-            LOGGER.info(String.format("Connected channel %s to connector %s, method: %s", incomingChannelName, connectorName.get(), method.toString()));
-            connected = true;
-        }
-
-        //Connect to downstream outgoing connector if any
-        Config outgoingChannelConfig = config.get("mp.messaging.outgoing").get(outgoingChannelName);
-        ConfigValue outgoingConnectorName = outgoingChannelConfig.get("connector").asString();
-        if (outgoingConnectorName.isPresent()) {
-            //Connect to connector
-            Config connectorConfig = config
-                    .get("mp.messaging.connector")
-                    .get(outgoingConnectorName.get());
-            org.eclipse.microprofile.config.Config augmentedConfig =
-                    AdHocConfigBuilder
-                            .from(outgoingChannelConfig)
-                            //It seams useless but its required by the spec
-                            .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, outgoingChannelName)
-                            .putAll(connectorConfig)
-                            .build();
-            subscriberBuilder = ((OutgoingConnectorFactory) getBeanInstance(getRouter()
-                    .getOutgoingConnectorFactory(outgoingConnectorName.get()), beanManager))
-                    .getSubscriberBuilder(augmentedConfig);
-            processor = new OutgoingConnectorProcessor(this);
-            processor.subscribe((Subscriber) subscriberBuilder.build());
-            connected = true;
-        } else {
-            // Connect to downstream Incoming methods with publisher
-            List incomingMethodChannels = getRouter().getIncomingSubscribers(getOutgoingChannelName());
-            if (incomingMethodChannels != null) {
-                for (IncomingMethodChannel s : getRouter().getIncomingSubscribers(getOutgoingChannelName())) {
-                    System.out.println("Connecting " + this.getOutgoingChannelName() + " " + this.method.getName() + " to " + s.method.getName());
-                    connected = true;
-                    s.connected = true;
-                    processor.subscribe(s.getSubscriber());
-                }
-            }
-        }
-        //Publisher is populated by upstream outgoing(OutgoingChannelMethod) or connector
-        publisher.subscribe(processor);
-    }
-
-    public void setPublisher(Publisher publisher) {
-        this.publisher = publisher;
-    }
-
-    protected void resolveSignatureType() {
-        Class returnType = this.method.getReturnType();
-        Class parameterType = this.method.getParameterTypes()[0];
-        if (Void.TYPE.equals(parameterType)) {
-            if (Processor.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_VOID_2_PROCESSOR;
-            } else if (ProcessorBuilder.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER;
-            } else {
-                throw new DeploymentException("Bad processor method signature " + method);
-            }
-        } else if (Publisher.class.equals(parameterType) && Publisher.class.equals(returnType)) {
-            this.type = Type.PROCESSOR_PUBLISHER_2_PUBLISHER;
-        } else if (PublisherBuilder.class.equals(parameterType) && PublisherBuilder.class.equals(returnType)) {
-            this.type = Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER;
-        } else {
-            if (Publisher.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_MSG_2_PUBLISHER;
-            } else if (CompletionStage.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_MSG_2_COMPL_STAGE;
-            } else {
-                this.type = Type.PROCESSOR_MSG_2_MSG;
-            }
-        }
-    }
-
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
new file mode 100644
index 00000000000..b9b016078a1
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import io.helidon.config.Config;
+import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.connector.IncomingConnector;
+import io.helidon.microprofile.messaging.connector.OutgoingConnector;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.util.Optional;
+
+public class UniversalChannel {
+    private String name;
+    private IncomingConnector incomingConnector;
+    private ProcessorMethod incomingProcessorMethod;
+    private IncomingMethod incomingMethod;
+    private OutgoingMethod outgoingMethod;
+    private OutgoingConnector outgoingConnector;
+    private ProcessorMethod outgoingProcessorMethod;
+    private Publisher publisher;
+    private Subscriber subscriber;
+    private Config config;
+    private ChannelRouter router;
+    private Optional upstreamChannel = Optional.empty();
+
+    public UniversalChannel(ChannelRouter router) {
+        this.router = router;
+        this.config = router.getConfig();
+    }
+
+    public void setIncoming(IncomingMethod incomingMethod) {
+        this.name = incomingMethod.getIncomingChannelName();
+        this.incomingMethod = incomingMethod;
+    }
+
+    public void setIncoming(ProcessorMethod processorMethod) {
+        this.name = processorMethod.getIncomingChannelName();
+        this.incomingProcessorMethod = processorMethod;
+        this.incomingProcessorMethod.setOutgoingChannel(this);
+    }
+
+    public void setOutgoing(ProcessorMethod processorMethod) {
+        this.name = processorMethod.getOutgoingChannelName();
+        this.outgoingProcessorMethod = processorMethod;
+        this.outgoingProcessorMethod.setIncomingChannel(this);
+    }
+
+    public void setOutgoing(OutgoingMethod outgoingMethod) {
+        this.name = outgoingMethod.getOutgoingChannelName();
+        this.outgoingMethod = outgoingMethod;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void connect() {
+        if (outgoingMethod != null) {
+            publisher = outgoingMethod.getPublisher();
+            System.out.print(outgoingMethod.method.getName() + " >> ");
+        } else if (outgoingProcessorMethod != null) {
+            publisher = outgoingProcessorMethod.getProcessor();
+            upstreamChannel = Optional.of(outgoingProcessorMethod.getOutgoingChannel());
+            System.out.print(outgoingProcessorMethod.method.getName() + " >> ");
+        } else if(outgoingConnector != null){
+            publisher = outgoingConnector.getPublisher(name);
+            System.out.print(outgoingConnector.getConnectorName() + " >> ");
+        } else {
+            throw new DeploymentException("No outgoing channel " + name + " found!");
+        }
+
+        if (incomingMethod != null) {
+            subscriber = incomingMethod.getSubscriber();
+            System.out.println(name + " >> " + incomingMethod.method.getName());
+            publisher.subscribe(subscriber);
+            //Continue connecting processor chain
+            upstreamChannel.ifPresent(UniversalChannel::connect);
+        } else if (incomingProcessorMethod != null) {
+            subscriber = incomingProcessorMethod.getProcessor();
+            System.out.println(name + " >> " + incomingProcessorMethod.method.getName());
+            publisher.subscribe(subscriber);
+            //Continue connecting processor chain
+            upstreamChannel.ifPresent(UniversalChannel::connect);
+        } else if (incomingConnector != null) {
+            Subscriber subscriber = incomingConnector.getSubscriber(name);
+            System.out.println(name + " >> " + incomingConnector.getConnectorName());
+            publisher.subscribe(subscriber);
+            //Continue connecting processor chain
+            upstreamChannel.ifPresent(UniversalChannel::connect);
+        } else {
+            throw new DeploymentException("No incoming channel " + name + " found!");
+        }
+    }
+
+    public boolean isLastInChain() {
+        return incomingProcessorMethod == null;
+    }
+
+    public void findConnectors() {
+        ConfigValue incomingConnectorName = config.get("mp.messaging.outgoing").get(name).get("connector").asString();
+        ConfigValue outgoingConnectorName = config.get("mp.messaging.incoming").get(name).get("connector").asString();
+        if (incomingConnectorName.isPresent()) {
+            incomingConnector = router.getIncomingConnector(incomingConnectorName.get())
+                    .orElseThrow(() -> new DeploymentException("No connector " + incomingConnectorName.get() + " found!"));
+        }
+        if (outgoingConnectorName.isPresent()) {
+            outgoingConnector = router.getOutgoingConnector(outgoingConnectorName.get())
+                    .orElseThrow(() -> new DeploymentException("No connector " + outgoingConnectorName.get() + " found!"));
+        }
+    }
+
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
new file mode 100644
index 00000000000..139c80e1d68
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import io.helidon.config.Config;
+import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.AdHocConfigBuilder;
+import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+public interface ConfigurableConnector {
+
+    String getConnectorName();
+
+    Config getRootConfig();
+
+    Config getChannelsConfig();
+
+    default org.eclipse.microprofile.config.Config getConnectorConfig(String channelName) {
+        Config channelConfig = getChannelsConfig()
+                .get(channelName);
+        ConfigValue connectorName = channelConfig
+                .get("connector")
+                .asString();
+
+        if (!connectorName.isPresent()) {
+            throw new DeploymentException("No connector configured for channel " + channelName);
+        }
+        if (!connectorName.get().equals(getConnectorName())) {
+            throw new DeploymentException("Connector name miss match for channel" + channelName);
+        }
+
+        Config connectorConfig = getRootConfig()
+                .get("mp.messaging.connector")
+                .get(connectorName.get());
+
+        return AdHocConfigBuilder
+                .from(channelConfig)
+                //It seams useless but its required by the spec
+                .put(ConnectorFactory.CHANNEL_NAME_ATTRIBUTE, channelName)
+                .putAll(connectorConfig)
+                .build();
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
new file mode 100644
index 00000000000..432f647dfe9
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import io.helidon.config.Config;
+import io.helidon.microprofile.messaging.channel.ChannelRouter;
+import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
+import org.reactivestreams.Subscriber;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class IncomingConnector implements SubscribingConnector {
+
+    private final Config config;
+    private String connectorName;
+    private OutgoingConnectorFactory connectorFactory;
+    private ChannelRouter router;
+    private Map subscriberMap = new HashMap<>();
+
+    public IncomingConnector(String connectorName, OutgoingConnectorFactory connectorFactory, ChannelRouter router) {
+        this.connectorName = connectorName;
+        this.connectorFactory = connectorFactory;
+        this.router = router;
+        this.config = router.getConfig();
+    }
+
+    @Override
+    public Subscriber getSubscriber(String channelName) {
+        Subscriber subscriber = subscriberMap.get(channelName);
+        if (subscriber == null) {
+            subscriber = connectorFactory.getSubscriberBuilder(getConnectorConfig(channelName)).build();
+            subscriberMap.put(channelName, subscriber);
+        }
+        return subscriber;
+    }
+
+    @Override
+    public String getConnectorName() {
+        return connectorName;
+    }
+
+    @Override
+    public Config getRootConfig() {
+        return config;
+    }
+
+
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
new file mode 100644
index 00000000000..ffa349177c6
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.connector;
+
+import io.helidon.config.Config;
+import io.helidon.microprofile.messaging.channel.ChannelRouter;
+import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OutgoingConnector implements PublishingConnector {
+
+    private final Config config;
+    private String connectorName;
+    private IncomingConnectorFactory connectorFactory;
+    private ChannelRouter router;
+    private Map publisherMap = new HashMap<>();
+
+    public OutgoingConnector(String connectorName, IncomingConnectorFactory connectorFactory, ChannelRouter router) {
+        this.connectorName = connectorName;
+        this.connectorFactory = connectorFactory;
+        this.router = router;
+        this.config = router.getConfig();
+    }
+
+    @Override
+    public String getConnectorName() {
+        return connectorName;
+    }
+
+    @Override
+    public Config getRootConfig() {
+        return config;
+    }
+
+    @Override
+    public Publisher getPublisher(String channelName) {
+        Publisher publisher = publisherMap.get(channelName);
+        if (publisher == null) {
+            publisher = connectorFactory
+                    .getPublisherBuilder(getConnectorConfig(channelName))
+                    .buildRs();
+            publisherMap.put(channelName, publisher);
+        }
+        return publisher;
+    }
+
+    @Override
+    public void subscribe(String channelName, Subscriber subscriber) {
+        getPublisher(channelName).subscribe(subscriber);
+    }
+}
\ No newline at end of file
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
similarity index 58%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
index 5c1ba9b9c5f..2661e8c9ea4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/OutgoingConnectorProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
@@ -15,19 +15,20 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.connector;
 
-import io.helidon.microprofile.messaging.channel.ProcessorMethodChannel;
-import org.eclipse.microprofile.reactive.messaging.Message;
+import io.helidon.config.Config;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
 
-public class OutgoingConnectorProcessor extends InternalProcessor {
-
-    public OutgoingConnectorProcessor(ProcessorMethodChannel processorMethodChannel) {
-        super(processorMethodChannel);
-    }
+public interface PublishingConnector extends ConfigurableConnector {
 
     @Override
-    protected Object wrapValue(Object value) {
-        return Message.of(value);
+    default Config getChannelsConfig() {
+        return getRootConfig().get("mp.messaging.incoming");
     }
-}
\ No newline at end of file
+
+    Publisher getPublisher(String channelName);
+
+    void subscribe(String channelName, Subscriber subscriber);
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
similarity index 63%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
index 3e55195e40c..b9e9ac12b74 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingConnectorChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
@@ -15,8 +15,17 @@
  *
  */
 
-package io.helidon.microprofile.messaging.channel;
+package io.helidon.microprofile.messaging.connector;
 
-public class IncomingConnectorChannel {
-    //TODO: Move connector logic here
+import io.helidon.config.Config;
+import org.reactivestreams.Subscriber;
+
+public interface SubscribingConnector extends ConfigurableConnector {
+
+    @Override
+    default Config getChannelsConfig() {
+        return getRootConfig().get("mp.messaging.outgoing");
+    }
+
+    Subscriber getSubscriber(String channelName);
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
index e6f9ae67a92..a247b24b1e6 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
@@ -18,7 +18,8 @@
 package io.helidon.microprofile.messaging.reactive;
 
 import io.helidon.microprofile.messaging.MessageUtils;
-import io.helidon.microprofile.messaging.channel.ProcessorMethodChannel;
+import io.helidon.microprofile.messaging.channel.ProcessorMethod;
+import org.eclipse.microprofile.reactive.messaging.Message;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
@@ -29,11 +30,11 @@
 public class InternalProcessor implements Processor {
 
 
-    private ProcessorMethodChannel processorMethodChannel;
+    private ProcessorMethod processorMethod;
     private Subscriber subscriber;
 
-    public InternalProcessor(ProcessorMethodChannel processorMethodChannel) {
-        this.processorMethodChannel = processorMethodChannel;
+    public InternalProcessor(ProcessorMethod processorMethod) {
+        this.processorMethod = processorMethod;
     }
 
     @Override
@@ -50,9 +51,9 @@ public void onSubscribe(Subscription s) {
     public void onNext(Object incomingValue) {
         try {
             //TODO: Has to be always one param in the processor, validate and propagate better
-            Method method = processorMethodChannel.getMethod();
+            Method method = processorMethod.getMethod();
             Class paramType = method.getParameterTypes()[0];
-            Object processedValue = method.invoke(processorMethodChannel.getBeanInstance(),
+            Object processedValue = method.invoke(processorMethod.getBeanInstance(),
                     MessageUtils.unwrap(incomingValue, paramType));
             subscriber.onNext(wrapValue(processedValue));
         } catch (IllegalAccessException | InvocationTargetException e) {
@@ -61,7 +62,7 @@ public void onNext(Object incomingValue) {
     }
 
     protected Object wrapValue(Object value) {
-        return value;
+        return MessageUtils.unwrap(value, Message.class);
     }
 
     @Override
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
new file mode 100644
index 00000000000..1852399aa8b
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.reactive;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class InternalPublisher implements Publisher {
+
+    private Method method;
+    private Object beanInstance;
+
+    public InternalPublisher(Method method, Object beanInstance) {
+        this.method = method;
+        this.beanInstance = beanInstance;
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        try {
+            s.onNext(method.invoke(beanInstance));
+            s.onComplete();
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            s.onError(e);
+        }
+    }
+
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
new file mode 100644
index 00000000000..165dfc6b387
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.reactive;
+
+import io.helidon.microprofile.messaging.channel.AbstractChannel;
+import io.helidon.microprofile.messaging.channel.ProcessorMethod;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.lang.reflect.InvocationTargetException;
+
+public class ProxyProcessor implements Processor {
+
+    private final ProcessorMethod processorMethod;
+    private final Publisher publisher;
+
+    public ProxyProcessor(ProcessorMethod processorMethod) {
+        this.processorMethod = processorMethod;
+        try {
+            if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER) {
+                PublisherBuilder paramPublisherBuilder = ReactiveStreams.fromPublisher(this);
+                publisher = ((PublisherBuilder) processorMethod
+                        .getMethod()
+                        .invoke(processorMethod.getBeanInstance(), paramPublisherBuilder)).buildRs();
+            } else {
+                throw new UnsupportedOperationException("Not implemented yet!");
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        publisher.subscribe(s);
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void onNext(Object o) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void onComplete() {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
index 0a57d773374..02b352ab4be 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
@@ -59,7 +59,7 @@ void connectorWithProcessorOnlyTest() throws InterruptedException {
                 "mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector",
                 "mp.messaging.outgoing.iterable-channel-out.connector", "iterable-connector");
         cdiContainer = startCdiContainer(p, IterableConnector.class, ConnectedOnlyProcessorBean.class);
-        assertTrue(IterableConnector.LATCH.await(20, TimeUnit.SECONDS));
+        assertTrue(IterableConnector.LATCH.await(2, TimeUnit.SECONDS));
     }
 
     @Test
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 7867927be32..cd7c928a280 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.microprofile.messaging.AbstractCDITest;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import javax.enterprise.inject.spi.DeploymentException;
@@ -54,6 +55,27 @@ void processorInSameBeanTest() throws InterruptedException {
                         + InnerProcessorBean.testLatch.getCount());
     }
 
+    @Test
+    void multipleProcessorTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(Collections.emptyMap(), MultipleProcessorBean.class);
+
+        // Wait till all messages are delivered
+        assertTrue(MultipleProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
+                , "All messages not delivered in time, number of unreceived messages: "
+                        + MultipleProcessorBean.testLatch.getCount());
+    }
+
+    @Test
+    @Disabled //TODO: Stream types
+    void multipleTypeProcessorTest() throws InterruptedException {
+        cdiContainer = startCdiContainer(Collections.emptyMap(), MultipleTypeProcessorChainBean.class);
+
+        // Wait till all messages are delivered
+        assertTrue(MultipleProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
+                , "All messages not delivered in time, number of unreceived messages: "
+                        + MultipleTypeProcessorChainBean.testLatch.getCount());
+    }
+
     @Test
     void primitiveProcessorTest() throws InterruptedException {
         cdiContainer = startCdiContainer(Collections.emptyMap(), PrimitiveProcessorBean.class);
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
new file mode 100644
index 00000000000..68d11e4be18
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+public class MultipleProcessorBean {
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toLowerCase).collect(Collectors.toSet());
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
+
+    @Outgoing("inner-processor")
+    public Publisher produceMessage() {
+        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-processor-2")
+    public String process(String msg) {
+        return msg.toUpperCase();
+    }
+
+    @Incoming("inner-processor-2")
+    @Outgoing("inner-consumer")
+    public String process2(String msg) {
+        return msg.toLowerCase();
+    }
+
+    @Incoming("inner-consumer")
+    public void receiveMessage(String msg) {
+        assertTrue(EXPECTED_DATA.contains(msg.toLowerCase()), "Unexpected message received");
+        testLatch.countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
new file mode 100644
index 00000000000..13ea5d6be05
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ApplicationScoped
+public class MultipleTypeProcessorChainBean {
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toLowerCase).collect(Collectors.toSet());
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
+
+    @Outgoing("inner-processor")
+    public Publisher produceMessage() {
+        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-processor-2")
+    public PublisherBuilder process(PublisherBuilder msg) {
+        return msg.map(String::toUpperCase);
+    }
+
+    @Incoming("inner-processor-2")
+    @Outgoing("inner-consumer")
+    public String process2(String msg) {
+        return msg.toLowerCase();
+    }
+
+    @Incoming("inner-consumer")
+    public void receiveMessage(String msg) {
+        assertTrue(EXPECTED_DATA.contains(msg.toLowerCase()), "Unexpected message received");
+        testLatch.countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
index ff46f0c8778..c56a4713efe 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
@@ -35,6 +35,7 @@
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -57,12 +58,21 @@ public class KafkaCdiExtensionTest extends AbstractCDITest {
 
     @Override
     protected Map cdiConfig() {
-        return mapOf(
-                "mp.messaging.incoming.test-channel.connector", KafkaConnectorFactory.CONNECTOR_NAME,
-                "mp.messaging.incoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString(),
-                "mp.messaging.incoming.test-channel.topic", TEST_TOPIC,
-                "mp.messaging.incoming.test-channel.key.deserializer", LongDeserializer.class.getName(),
-                "mp.messaging.incoming.test-channel.value.deserializer", StringDeserializer.class.getName());
+        Map p = new HashMap<>();
+        p.putAll(mapOf(
+                "mp.messaging.incoming.test-channel-1.connector", KafkaConnectorFactory.CONNECTOR_NAME,
+                "mp.messaging.incoming.test-channel-1.bootstrap.servers", kafkaResource.getKafkaConnectString(),
+                "mp.messaging.incoming.test-channel-1.topic", TEST_TOPIC,
+                "mp.messaging.incoming.test-channel-1.key.deserializer", LongDeserializer.class.getName(),
+                "mp.messaging.incoming.test-channel-1.value.deserializer", StringDeserializer.class.getName()));
+        p.putAll(mapOf(
+                "mp.messaging.incoming.test-channel-2.connector", KafkaConnectorFactory.CONNECTOR_NAME,
+                "mp.messaging.incoming.test-channel-2.bootstrap.servers", kafkaResource.getKafkaConnectString(),
+                "mp.messaging.incoming.test-channel-2.topic", TEST_TOPIC,
+                "mp.messaging.incoming.test-channel-2.key.deserializer", LongDeserializer.class.getName(),
+                "mp.messaging.incoming.test-channel-2.value.deserializer", StringDeserializer.class.getName())
+        );
+        return p;
     }
 
     @Override
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
index e1da09ef2f5..fce4f22d84f 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
@@ -37,13 +37,13 @@ public class KafkaConsumingBean {
     //Two methods -> two consumers of same topic means twice as much received messages
     public static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() * 2);
 
-    @Incoming("test-channel")
+    @Incoming("test-channel-1")
     public void receiveMPMessage(Message> msg) {
         assertTrue(TEST_DATA.contains(msg.getPayload().value()));
         testChannelLatch.countDown();
     }
 
-    @Incoming("test-channel")
+    @Incoming("test-channel-2")
     public void receiveKafkaConsumerRecord(ConsumerRecord msg) {
         assertTrue(TEST_DATA.contains(msg.value()));
         testChannelLatch.countDown();
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 5195456202a..e009c9df771 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -1,6 +1,7 @@
 package io.helidon.microprofile.reactive;
 
 import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
@@ -26,24 +27,29 @@ public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
     @Override
     public  Publisher buildPublisher(Graph graph) throws UnsupportedStageException {
         Collection stages = graph.getStages();
-        if (stages.size() != 1) {
-            //TODO: Support more than one stage
-            throw new RuntimeException("Exactly one stage is supported for now");
-        }
 
-        Stage firstStage = stages.iterator().next();
-        if (firstStage instanceof Stage.PublisherStage) {
-            Stage.PublisherStage publisherStage = (Stage.PublisherStage) firstStage;
-            return (Publisher) publisherStage.getRsPublisher();
-        } else if (firstStage instanceof Stage.Of) {
-            //Collection
-            Stage.Of stageOf = (Stage.Of) firstStage;
-            return Multi.justMP(StreamSupport.stream(stageOf.getElements().spliterator(), false)
-                    .map(e -> (T) e)
-                    .collect(Collectors.toList()));
-        } else {
-            throw new UnsupportedStageException(firstStage);
+        Publisher publisher = null;
+
+        for (Stage stage : stages) {
+            if (stage instanceof Stage.PublisherStage) {
+                Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage;
+                publisher = (Publisher) publisherStage.getRsPublisher();
+            } else if (stage instanceof Stage.Map) {
+                Stage.Map mapStage = (Stage.Map) stage;
+                //TODO: maps...
+                //mapStage.getMapper().apply(pub);
+            } else if (stage instanceof Stage.Of) {
+                //Collection
+                Stage.Of stageOf = (Stage.Of) stage;
+                return Multi.justMP(StreamSupport.stream(stageOf.getElements().spliterator(), false)
+                        .map(e -> (T) e)
+                        .collect(Collectors.toList()));
+            } else {
+                throw new UnsupportedStageException(stage);
+            }
         }
+
+        return publisher;
     }
 
     @Override

From 651c7359e9e9626d04b36e866fcd0f6395ac43cb Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 12 Nov 2019 15:34:00 +0100
Subject: [PATCH 11/66] Reactive engine - support from more stages (peek,
 filter)

Signed-off-by: Daniel Kec 
---
 .../common/reactive/FilterProcessor.java      | 41 ++++++++
 .../io/helidon/common/reactive/Multi.java     | 40 +++++---
 .../common/reactive/MultiFromPublisher.java   | 38 +-------
 .../common/reactive/PeekProcessor.java        | 40 ++++++++
 .../messaging/channel/UniversalChannel.java   |  2 +
 .../messaging/reactive/InternalProcessor.java | 10 ++
 .../reactive/InternalSubscriber.java          |  1 -
 .../messaging/reactive/ProxyProcessor.java    | 30 +++++-
 .../messaging/AbstractCDITest.java            | 49 ++++++++++
 .../messaging/CountableTestBean.java          | 24 +++++
 .../messaging/ReactiveEngineTest.java         | 93 ------------------
 .../messaging/inner/InnerChannelTest.java     | 71 +++++---------
 .../messaging/inner/InnerProcessorBean.java   | 22 +++--
 .../messaging/inner/InternalChannelsBean.java | 21 ++--
 .../inner/MultipleProcessorBean.java          | 28 ++++--
 .../inner/MultipleTypeProcessorChainBean.java | 28 ++++--
 .../NotConnectedOutgoingChannelBean.java      |  4 +-
 .../inner/PrimitiveProcessorBean.java         |  5 +-
 microprofile/reactive-bridge/pom.xml          | 11 +++
 .../reactive/CompletionSubscriber.java        | 73 ++++++++++++++
 .../reactive/ConsumableSubscriber.java        | 36 -------
 .../reactive/HelidonReactiveStreamEngine.java | 50 ++++------
 .../microprofile/reactive/MultiRS.java        | 66 +++++++++++++
 .../reactive/MultiStagesCollector.java        | 95 ++++++++----------
 .../reactive/hybrid/HybridPublisher.java      | 54 +++++++++++
 .../reactive/hybrid/HybridSubscriber.java     | 90 +++++++++++++++++
 .../reactive/hybrid/HybridSubscription.java   | 67 +++++++++++++
 .../reactive/ConsumableSubscriber.java        | 65 +++++++++++++
 .../microrofile/reactive/EngineTest.java      | 96 +++++++++++++++++++
 .../reactive/IntSequencePublisher.java        | 60 ++++++++++++
 30 files changed, 953 insertions(+), 357 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CountableTestBean.java
 delete mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
 delete mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
 create mode 100644 microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
 create mode 100644 microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
 create mode 100644 microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
new file mode 100644
index 00000000000..1ea122b023a
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.function.Predicate;
+
+/**
+ * Processor filtering stream with supplied predicate
+ *
+ * @param  both input/output type
+ */
+public class FilterProcessor extends BaseProcessor implements Multi {
+
+    private Predicate predicate;
+
+    public FilterProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        if (predicate.test(item)) {
+            submit(item);
+        }
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 6e1cbb6a6c4..5c17bc8ae9f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -22,6 +22,9 @@
 
 import io.helidon.common.mapper.Mapper;
 
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
 /**
  * Multiple items publisher facility.
  * @param  item type
@@ -42,6 +45,32 @@ default  Multi map(Mapper mapper) {
         return processor;
     }
 
+    /**
+     * Invoke provided consumer for every item in stream
+     *
+     * @param consumer consumer to be invoked
+     * @param  consumer argument type
+     * @return Multi
+     */
+    default  Multi peek(Consumer consumer) {
+        PeekProcessor processor = new PeekProcessor(consumer);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Filter stream items with provided predicate
+     *
+     * @param predicate predicate to filter stream with
+     * @param  type of the predicate argument
+     * @return Multi
+     */
+    default  Multi filter(Predicate predicate) {
+        FilterProcessor processor = new FilterProcessor(predicate);
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Collect the items of this {@link Multi} instance into a {@link Single} of {@link List}.
      *
@@ -116,17 +145,6 @@ static  Multi just(T... items) {
         return new MultiFromPublisher<>(new FixedItemsPublisher<>(List.of(items)));
     }
 
-    //TODO: This is just POC, hide it behind org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams
-    @SafeVarargs
-    static  org.reactivestreams.Publisher justMP(T... items) {
-        return new MultiFromPublisher<>(new FixedItemsPublisher<>(listOf(items)));
-    }
-
-    //TODO: This is just POC, hide it behind org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams
-    static  org.reactivestreams.Publisher justMP(Collection items) {
-        return new MultiFromPublisher<>(new FixedItemsPublisher<>(items));
-    }
-
     /**
      * Create a {@link Multi} instance that reports the given exception to its subscriber(s). The exception is reported by
      * invoking {@link Subscriber#onError(java.lang.Throwable)} when {@link Publisher#subscribe(Subscriber)} is called.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
index 38e49320325..09051d5823b 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
@@ -27,7 +27,7 @@
  *
  * @param  items type
  */
-final class MultiFromPublisher implements Multi, org.reactivestreams.Publisher {
+final class MultiFromPublisher implements Multi {
 
     private final Flow.Publisher source;
 
@@ -40,40 +40,4 @@ final class MultiFromPublisher implements Multi, org.reactivestreams.Publi
     public void subscribe(Subscriber subscriber) {
         source.subscribe(subscriber);
     }
-
-    //TODO: This is just POC
-    @Override
-    public void subscribe(org.reactivestreams.Subscriber s) {
-        source.subscribe(new Subscriber() {
-            @Override
-            public void onSubscribe(Flow.Subscription subscription) {
-                s.onSubscribe(new Subscription() {
-                    @Override
-                    public void request(long n) {
-                        subscription.request(n);
-                    }
-
-                    @Override
-                    public void cancel() {
-                        subscription.cancel();
-                    }
-                });
-            }
-
-            @Override
-            public void onNext(T item) {
-                s.onNext(item);
-            }
-
-            @Override
-            public void onError(Throwable throwable) {
-                s.onError(throwable);
-            }
-
-            @Override
-            public void onComplete() {
-                s.onComplete();
-            }
-        });
-    }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
new file mode 100644
index 00000000000..9ed1a876900
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.function.Consumer;
+
+/**
+ * Invoke supplied consumer for every item in the stream
+ *
+ * @param  both input/output type
+ */
+public class PeekProcessor extends BaseProcessor implements Multi {
+
+    private Consumer consumer;
+
+    public PeekProcessor(Consumer consumer) {
+        this.consumer = consumer;
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        consumer.accept(item);
+        submit(item);
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
index b9b016078a1..3b0fcb95cbb 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
@@ -21,6 +21,8 @@
 import io.helidon.config.ConfigValue;
 import io.helidon.microprofile.messaging.connector.IncomingConnector;
 import io.helidon.microprofile.messaging.connector.OutgoingConnector;
+import io.helidon.microprofile.messaging.reactive.ProxyProcessor;
+import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
index a247b24b1e6..4b204c3218c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
@@ -27,6 +27,16 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
+/**
+ * Process every item in stream by method ex:
+ * 
{@code
+ *      @Incoming("inner-processor")
+ *      @Outgoing("inner-consumer")
+ *      public String process2(String msg) {
+ *          return msg.toLowerCase();
+ *      }
+ * }

+ */
 public class InternalProcessor implements Processor {
 
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
index 91569198a57..bd37d6963ff 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
@@ -68,7 +68,6 @@ public void onNext(Object message) {
 
     @Override
     public void onError(Throwable t) {
-        //TODO: Propagate error
         throw new RuntimeException(t);
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
index 165dfc6b387..262febc412c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
@@ -21,6 +21,7 @@
 import io.helidon.microprofile.messaging.channel.ProcessorMethod;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.jboss.weld.exceptions.DeploymentException;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -28,10 +29,22 @@
 
 import java.lang.reflect.InvocationTargetException;
 
+/**
+ * Passes publisher to processor method ex:
+ * 
{@code
+ *     @Incoming("inner-processor")
+ *     @Outgoing("inner-processor-2")
+ *     public PublisherBuilder process(PublisherBuilder msg) {
+ *         return msg;
+ *     }
+ * }

+ */
 public class ProxyProcessor implements Processor {
 
     private final ProcessorMethod processorMethod;
     private final Publisher publisher;
+    private Subscriber subscriber;
+    private boolean subscribed = false;
 
     public ProxyProcessor(ProcessorMethod processorMethod) {
         this.processorMethod = processorMethod;
@@ -52,26 +65,33 @@ public ProxyProcessor(ProcessorMethod processorMethod) {
 
     @Override
     public void subscribe(Subscriber s) {
-        publisher.subscribe(s);
+        if (publisher == null) {
+            subscriber = s;
+        } else if(!subscribed){
+            subscribed = true;
+            publisher.subscribe(s);
+        }else{
+            throw new DeploymentException("Already subscribed");
+        }
     }
 
     @Override
     public void onSubscribe(Subscription s) {
-        throw new UnsupportedOperationException();
+        subscriber.onSubscribe(s);
     }
 
     @Override
     public void onNext(Object o) {
-        throw new UnsupportedOperationException();
+        subscriber.onNext(o);
     }
 
     @Override
     public void onError(Throwable t) {
-        throw new UnsupportedOperationException();
+        subscriber.onError(t);
     }
 
     @Override
     public void onComplete() {
-        throw new UnsupportedOperationException();
+        subscriber.onComplete();
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index 8bf1be680ca..d210efffb43 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -37,15 +37,19 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.logging.LogManager;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 public abstract class AbstractCDITest {
@@ -97,10 +101,21 @@ public void tearDown() {
         }
     }
 
+
     protected  void forEachBean(Class beanType, Annotation annotation, Consumer consumer) {
         cdiContainer.select(beanType, annotation).stream().forEach(consumer);
     }
 
+    public void assertAllReceived(CountableTestBean bean) {
+        try {
+            assertTrue(bean.getTestLatch().await(2, TimeUnit.SECONDS)
+                    , "All messages not delivered in time, number of unreceived messages: "
+                            + bean.getTestLatch().getCount());
+        } catch (InterruptedException e) {
+            fail(e);
+        }
+    }
+
     public static SeContainer startCdiContainer(Map p, Class... beanClasses) {
         return startCdiContainer(p, new HashSet<>(Arrays.asList(beanClasses)));
     }
@@ -122,4 +137,38 @@ public static SeContainer startCdiContainer(Map p, Set>
         initializer.addBeanClasses(beanClasses.toArray(new Class[0]));
         return initializer.initialize();
     }
+
+    protected static final class CdiTestCase {
+        private String name;
+        private Class[] clazzes;
+
+        private CdiTestCase(String name, Class... clazzes) {
+            this.name = name;
+            this.clazzes = clazzes;
+        }
+
+        public static CdiTestCase from(Class clazz) {
+            return new CdiTestCase(clazz.getSimpleName(), clazz);
+        }
+
+        public static CdiTestCase from(String name, Class... clazzes) {
+            return new CdiTestCase(name, clazzes);
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+
+        public Class[] getClazzes() {
+            return clazzes;
+        }
+
+        public List> getCountableBeanClasses() {
+            return Arrays.stream(clazzes)
+                    .filter(CountableTestBean.class::isAssignableFrom)
+                    .map(c -> (Class) c)
+                    .collect(Collectors.toList());
+        }
+    }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CountableTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CountableTestBean.java
new file mode 100644
index 00000000000..9032cff2959
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CountableTestBean.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import java.util.concurrent.CountDownLatch;
+
+public interface CountableTestBean {
+    CountDownLatch getTestLatch();
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
deleted file mode 100644
index dfea4734781..00000000000
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/ReactiveEngineTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging;
-
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.junit.jupiter.api.Test;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
-//TODO: Move to reactive bridge module
-public class ReactiveEngineTest {
-
-    @Test
-    void multipleStages() {
-        // Create a stream of words
-        ReactiveStreams.of("hello", "from", "helidon", "reactive", "stream", "operators")
-                .map(String::toUpperCase) // Transform the words
-                .filter(s -> s.length() > 4) // Filter items
-                .forEach(word -> System.out.println(">> " + word)) // Terminal operation
-                .run(); // Run it (create the streams, subscribe to it...)
-    }
-
-    @Test
-    void testTestHelidon() {
-        Publisher publisher = ReactiveStreams.of("test1", "test2", "test3")
-                .buildRs();
-        LatchSubscriber subscriber = new LatchSubscriber<>();
-
-        ReactiveStreams
-                .fromPublisher(publisher)
-                .to(ReactiveStreams.fromSubscriber(subscriber))
-                .run()
-                .toCompletableFuture();
-        subscriber.assertNextCalled();
-    }
-
-    private class LatchSubscriber extends CountDownLatch implements Subscriber {
-
-        public LatchSubscriber() {
-            super(1);
-        }
-
-
-        @Override
-        public void onSubscribe(Subscription s) {
-
-        }
-
-        @Override
-        public void onNext(T t) {
-            countDown();
-        }
-
-        @Override
-        public void onError(Throwable t) {
-
-        }
-
-        @Override
-        public void onComplete() {
-
-        }
-
-        public void assertNextCalled() {
-            try {
-                assertTrue(this.await(2, TimeUnit.SECONDS));
-            } catch (InterruptedException e) {
-                fail(e);
-            }
-        }
-    }
-}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index cd7c928a280..9bd3d81fe36 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -18,16 +18,18 @@
 package io.helidon.microprofile.messaging.inner;
 
 import io.helidon.microprofile.messaging.AbstractCDITest;
-import org.junit.jupiter.api.Disabled;
+import io.helidon.microprofile.messaging.CountableTestBean;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
+import javax.enterprise.inject.spi.CDI;
 import javax.enterprise.inject.spi.DeploymentException;
 
 import java.util.Collections;
-import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class InnerChannelTest extends AbstractCDITest {
 
@@ -36,54 +38,25 @@ public void setUp() {
         //Starting container manually
     }
 
-    @Test
-    void internalChannelsInSameBeanTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), InternalChannelsBean.class);
-        // Wait till all messages are delivered
-        assertTrue(InternalChannelsBean.publisher_string_latch.await(2, TimeUnit.SECONDS)
-                , "All messages not delivered in time, number of unreceived messages: "
-                        + InternalChannelsBean.publisher_string_latch.getCount());
-    }
-
-    @Test
-    void processorInSameBeanTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), InnerProcessorBean.class);
-
-        // Wait till all messages are delivered
-        assertTrue(InnerProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
-                , "All messages not delivered in time, number of unreceived messages: "
-                        + InnerProcessorBean.testLatch.getCount());
+    static Stream testCaseSource() {
+        return Stream.of(
+                CdiTestCase.from(InternalChannelsBean.class),
+                CdiTestCase.from(InnerProcessorBean.class),
+                CdiTestCase.from(MultipleProcessorBean.class),
+                CdiTestCase.from(MultipleTypeProcessorChainBean.class),
+                CdiTestCase.from(PrimitiveProcessorBean.class)
+        );
     }
 
-    @Test
-    void multipleProcessorTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), MultipleProcessorBean.class);
-
-        // Wait till all messages are delivered
-        assertTrue(MultipleProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
-                , "All messages not delivered in time, number of unreceived messages: "
-                        + MultipleProcessorBean.testLatch.getCount());
-    }
-
-    @Test
-    @Disabled //TODO: Stream types
-    void multipleTypeProcessorTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), MultipleTypeProcessorChainBean.class);
-
-        // Wait till all messages are delivered
-        assertTrue(MultipleProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
-                , "All messages not delivered in time, number of unreceived messages: "
-                        + MultipleTypeProcessorChainBean.testLatch.getCount());
-    }
-
-    @Test
-    void primitiveProcessorTest() throws InterruptedException {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), PrimitiveProcessorBean.class);
-
-        // Wait till all messages are delivered
-        assertTrue(PrimitiveProcessorBean.testLatch.await(2, TimeUnit.SECONDS)
-                , "All messages not delivered in time, number of unreceived messages: "
-                        + PrimitiveProcessorBean.testLatch.getCount());
+    @ParameterizedTest
+    @MethodSource("testCaseSource")
+    void innerChannelBeanTest(CdiTestCase testCase) {
+        cdiContainer = startCdiContainer(Collections.emptyMap(), testCase.getClazzes());
+        testCase.getCountableBeanClasses().forEach(c -> {
+            CountableTestBean countableTestBean = CDI.current().select(c).get();
+            // Wait till all messages are delivered
+            assertAllReceived(countableTestBean);
+        });
     }
 
     @Test
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
index 30cb7d72232..e1759f93acc 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerProcessorBean.java
@@ -31,7 +31,8 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
@@ -44,18 +45,18 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.stream.Collectors;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 @ApplicationScoped
-public class InnerProcessorBean {
+public class InnerProcessorBean implements CountableTestBean {
 
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
-    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toUpperCase).collect(Collectors.toSet());
+    public static Set EXPECTED_DATA = TEST_DATA.stream()
+            .map(String::toUpperCase)
+            .collect(Collectors.toSet());
     public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
 
     @Outgoing("inner-processor")
     public Publisher produceMessage() {
-        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+        return MultiRS.just(TEST_DATA.stream());
     }
 
     @Incoming("inner-processor")
@@ -66,8 +67,13 @@ public String process(String msg) {
 
     @Incoming("inner-consumer")
     public void receiveMessage(String msg) {
-        assertTrue(TEST_DATA.contains(msg.toLowerCase()), "Unexpected message received");
-        testLatch.countDown();
+        if (EXPECTED_DATA.contains(msg)) {
+            testLatch.countDown();
+        }
     }
 
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
index ef25d0824d7..eb7442ef351 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InternalChannelsBean.java
@@ -16,7 +16,8 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
@@ -28,22 +29,26 @@
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 @ApplicationScoped
-public class InternalChannelsBean {
+public class InternalChannelsBean implements CountableTestBean {
 
     private static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2"));
-    public static CountDownLatch publisher_string_latch = new CountDownLatch(TEST_DATA.size());
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
 
     @Outgoing("intenal-publisher-string")
     public Publisher produceMessage() {
-        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+        return MultiRS.just(TEST_DATA.stream());
     }
 
     @Incoming("intenal-publisher-string")
     public void receiveMethod(String msg) {
-        assertTrue(TEST_DATA.contains(msg), "Unexpected message received");
-        publisher_string_latch.countDown();
+        if (TEST_DATA.contains(msg)) {
+            testLatch.countDown();
+        }
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
index 68d11e4be18..bd3854a48a0 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleProcessorBean.java
@@ -17,7 +17,8 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
@@ -30,34 +31,41 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.stream.Collectors;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 @ApplicationScoped
-public class MultipleProcessorBean {
+public class MultipleProcessorBean implements CountableTestBean {
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
-    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toLowerCase).collect(Collectors.toSet());
+    public static Set EXPECTED_DATA = TEST_DATA.stream()
+            .map(String::toLowerCase)
+            .map(s -> s + "-processed")
+            .collect(Collectors.toSet());
     public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
 
     @Outgoing("inner-processor")
     public Publisher produceMessage() {
-        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+        return MultiRS.just(TEST_DATA.stream());
     }
 
     @Incoming("inner-processor")
     @Outgoing("inner-processor-2")
     public String process(String msg) {
-        return msg.toUpperCase();
+        return msg.toLowerCase();
     }
 
     @Incoming("inner-processor-2")
     @Outgoing("inner-consumer")
     public String process2(String msg) {
-        return msg.toLowerCase();
+        return msg + "-processed";
     }
 
     @Incoming("inner-consumer")
     public void receiveMessage(String msg) {
-        assertTrue(EXPECTED_DATA.contains(msg.toLowerCase()), "Unexpected message received");
-        testLatch.countDown();
+        if (EXPECTED_DATA.contains(msg)) {
+            testLatch.countDown();
+        }
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
index 13ea5d6be05..01ddfb98102 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
@@ -17,7 +17,8 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
@@ -31,34 +32,41 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.stream.Collectors;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 @ApplicationScoped
-public class MultipleTypeProcessorChainBean {
+public class MultipleTypeProcessorChainBean implements CountableTestBean {
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
-    public static Set EXPECTED_DATA = TEST_DATA.stream().map(String::toLowerCase).collect(Collectors.toSet());
+    public static Set EXPECTED_DATA = TEST_DATA.stream()
+            .map(String::toLowerCase)
+            .map(s -> s + "-processed")
+            .collect(Collectors.toSet());
     public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
 
     @Outgoing("inner-processor")
     public Publisher produceMessage() {
-        return Multi.justMP(TEST_DATA.toArray(new String[0]));
+        return MultiRS.just(TEST_DATA.stream());
     }
 
     @Incoming("inner-processor")
     @Outgoing("inner-processor-2")
     public PublisherBuilder process(PublisherBuilder msg) {
-        return msg.map(String::toUpperCase);
+        return msg.map(s -> s.toLowerCase());
     }
 
     @Incoming("inner-processor-2")
     @Outgoing("inner-consumer")
     public String process2(String msg) {
-        return msg.toLowerCase();
+        return msg + "-processed";
     }
 
     @Incoming("inner-consumer")
     public void receiveMessage(String msg) {
-        assertTrue(EXPECTED_DATA.contains(msg.toLowerCase()), "Unexpected message received");
-        testLatch.countDown();
+        if (EXPECTED_DATA.contains(msg)) {
+            testLatch.countDown();
+        }
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
index 1cf016c2ea9..90d18e71b56 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
@@ -16,7 +16,7 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
 
@@ -27,6 +27,6 @@ public class NotConnectedOutgoingChannelBean {
 
     @Outgoing("not-existing-channel")
     public Publisher produceMessage() {
-        return Multi.justMP("t1", "t2");
+        return MultiRS.just("t1", "t2");
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
index 2632ee28016..4412ee05971 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
@@ -17,7 +17,7 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
@@ -25,7 +25,6 @@
 import javax.enterprise.context.ApplicationScoped;
 
 import java.util.concurrent.CountDownLatch;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 @ApplicationScoped
@@ -35,7 +34,7 @@ public class PrimitiveProcessorBean {
 
     @Outgoing("inner-processor")
     public Publisher produceMessage() {
-        return Multi.justMP(IntStream.range(0, 10).boxed().collect(Collectors.toList()));
+        return MultiRS.just(IntStream.range(0, 10).boxed());
     }
 
     @Incoming("inner-processor")
diff --git a/microprofile/reactive-bridge/pom.xml b/microprofile/reactive-bridge/pom.xml
index 6e237d54963..0e6f054674e 100644
--- a/microprofile/reactive-bridge/pom.xml
+++ b/microprofile/reactive-bridge/pom.xml
@@ -41,5 +41,16 @@
             microprofile-reactive-streams-operators-api
             1.0.1
         
+        
+            org.eclipse.microprofile.reactive-streams-operators
+            microprofile-reactive-streams-operators-core
+            1.0.1
+        
+        
+            org.junit.jupiter
+            junit-jupiter
+            RELEASE
+            test
+        
     
 
\ No newline at end of file
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
new file mode 100644
index 00000000000..02337a6e0e3
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.concurrent.CompletionStage;
+
+/**
+ * Replacement for buggy DefaultCompletionSubscriber
+ * 

+ * https://github.com/eclipse/microprofile-reactive-streams-operators/issues/129#issue-521492223
+ *
+ * @param 
+ * @param 
+ */
+public class CompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
+
+    private final Subscriber subscriber;
+    private final CompletionStage completion;
+
+    public static  CompletionSubscriber of(Subscriber subscriber, CompletionStage completion) {
+        return new CompletionSubscriber<>(subscriber, completion);
+    }
+
+    private CompletionSubscriber(Subscriber subscriber, CompletionStage completion) {
+        this.subscriber = subscriber;
+        this.completion = completion;
+    }
+
+    @Override
+    public CompletionStage getCompletion() {
+        return completion;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        subscriber.onSubscribe(s);
+    }
+
+    @Override
+    public void onNext(T t) {
+        subscriber.onNext(t);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+        completion.toCompletableFuture().completeExceptionally(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+        completion.toCompletableFuture().complete(null);
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java
deleted file mode 100644
index c6bd1d5608e..00000000000
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/ConsumableSubscriber.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package io.helidon.microprofile.reactive;
-
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
-import java.util.function.Consumer;
-
-public class ConsumableSubscriber implements Subscriber {
-
-    private Consumer onNext;
-
-    public ConsumableSubscriber(Consumer onNext) {
-        this.onNext = onNext;
-    }
-
-    @Override
-    public void onSubscribe(Subscription s) {
-        System.out.println(s);
-
-    }
-
-    @Override
-    public void onNext(T o) {
-        onNext.accept(o);
-    }
-
-    @Override
-    public void onError(Throwable t) {
-
-    }
-
-    @Override
-    public void onComplete() {
-
-    }
-}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index e009c9df771..2b0154ae71f 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -1,7 +1,22 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
 
-import io.helidon.common.reactive.Multi;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
@@ -17,8 +32,6 @@
 import java.util.concurrent.CompletionStage;
 import java.util.function.BiConsumer;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
 public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
 
@@ -26,30 +39,10 @@ public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
 
     @Override
     public  Publisher buildPublisher(Graph graph) throws UnsupportedStageException {
+        MultiStagesCollector multiStagesCollector = new MultiStagesCollector<>();
         Collection stages = graph.getStages();
-
-        Publisher publisher = null;
-
-        for (Stage stage : stages) {
-            if (stage instanceof Stage.PublisherStage) {
-                Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage;
-                publisher = (Publisher) publisherStage.getRsPublisher();
-            } else if (stage instanceof Stage.Map) {
-                Stage.Map mapStage = (Stage.Map) stage;
-                //TODO: maps...
-                //mapStage.getMapper().apply(pub);
-            } else if (stage instanceof Stage.Of) {
-                //Collection
-                Stage.Of stageOf = (Stage.Of) stage;
-                return Multi.justMP(StreamSupport.stream(stageOf.getElements().spliterator(), false)
-                        .map(e -> (T) e)
-                        .collect(Collectors.toList()));
-            } else {
-                throw new UnsupportedStageException(stage);
-            }
-        }
-
-        return publisher;
+        stages.stream().collect(multiStagesCollector);
+        return multiStagesCollector.getPublisher();
     }
 
     @Override
@@ -127,9 +120,6 @@ public  CompletionStage buildCompletion(Graph graph) throws UnsupportedSta
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
         CompletionStage completionStage = (CompletionStage) multiStagesCollector.toCompletableStage();
-        completionStage.exceptionally(t -> {
-            throw new RuntimeException(t);
-        });
         return completionStage;
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
new file mode 100644
index 00000000000..d62b73b1cb8
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
+import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Conversion methods between Helidon reactive streams and the "Reactive Streams"
+ */
+public interface MultiRS {
+
+    public static  Flow.Subscriber from(Subscriber subscriber) {
+        return HybridSubscriber.from(subscriber);
+    }
+
+    public static  Subscriber from(Flow.Subscriber subscriber) {
+        return HybridSubscriber.from(subscriber);
+    }
+
+    public static  Flow.Publisher from(Publisher publisher) {
+        return HybridPublisher.from(publisher);
+    }
+
+    public static  Publisher from(Flow.Publisher publisher) {
+        return HybridPublisher.from(publisher);
+    }
+
+    public static  Multi toMulti(Publisher publisher) {
+        return Multi.from(HybridPublisher.from(publisher));
+    }
+
+    public static  Multi toMulti(Flow.Publisher publisher) {
+        return Multi.from(publisher);
+    }
+
+    public static  Publisher just(Stream stream) {
+        return MultiRS.from(Multi.just(stream.collect(Collectors.toList())));
+    }
+
+    public static  Publisher just(U... items) {
+        return MultiRS.from(Multi.just(items));
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index 168f1045df7..5c390352a37 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -16,20 +16,22 @@
 
 package io.helidon.microprofile.reactive;
 
-import io.helidon.common.mapper.Mapper;
 import io.helidon.common.reactive.Multi;
-import io.helidon.common.reactive.Single;
-import io.helidon.common.reactive.valve.Valves;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
+import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -37,82 +39,75 @@
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
-public class MultiStagesCollector implements Collector, CompletionStage> {
+public class MultiStagesCollector implements Collector, CompletionStage> {
 
-    private Multi multi = null;
-    private Single single = null;
+    private Multi multi = null;
+    private CompletableFuture completableFuture = null;
 
     @Override
-    public Supplier> supplier() {
+    public Supplier> supplier() {
         return () -> multi != null ? multi : Multi.empty();
     }
 
+    public Publisher getPublisher() {
+        return MultiRS.from(multi);
+    }
+
     @Override
-    public BiConsumer, Stage> accumulator() {
+    public BiConsumer, Stage> accumulator() {
         //MP Stages to Helidon multi streams mapping
         return (m, stage) -> {
 
             // Create stream
             if (stage instanceof Stage.PublisherStage) {
                 Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage;
-                if (publisherStage.getRsPublisher() instanceof Multi) {
-                    multi = (Multi) ((Stage.PublisherStage) stage).getRsPublisher();
-                } else {
+                Publisher rsPublisher = (Publisher) publisherStage.getRsPublisher();
+                multi = MultiRS.toMulti(rsPublisher);
 
-                    throw new UnsupportedStageException(stage);
-                }
             } else if (stage instanceof Stage.Of) {
                 //Collection
                 Stage.Of stageOf = (Stage.Of) stage;
-                multi = Multi.just(StreamSupport.stream(stageOf.getElements().spliterator(), false)
-                        .collect(Collectors.toList()));
+                List fixedData = StreamSupport.stream(stageOf.getElements().spliterator(), false)
+                        .collect(Collectors.toList());
+                multi = (Multi) Multi.just(fixedData);
 
             } else if (stage instanceof Stage.Map) {
                 // Transform stream
-                Stage.Map stageMap = (Stage.Map) stage;
-                multi = multi.map(new Mapper() {
-                    @Override
-                    public Object map(Object t) {
-                        Function mapper = (Function) stageMap.getMapper();
-                        return mapper.apply(t);
-                    }
-                });
+                Stage.Map mapStage = (Stage.Map) stage;
+                Function mapper = (Function) mapStage.getMapper();
+                multi = Multi.from(multi).map(mapper::apply);
 
             } else if (stage instanceof Stage.Filter) {
                 //Filter stream
                 Stage.Filter stageFilter = (Stage.Filter) stage;
-                Predicate predicate = (Predicate) stageFilter.getPredicate();
-                //TODO: Valve is deprecated, plan is implement filter in Multi
-                multi = Multi.from(Valves.from(multi).filter(predicate).toPublisher());
+                Predicate predicate = (Predicate) stageFilter.getPredicate();
+                multi = multi.filter(predicate);
+
+            } else if (stage instanceof Stage.Peek) {
+                Stage.Peek peekStage = (Stage.Peek) stage;
+                Consumer peekConsumer = (Consumer) peekStage.getConsumer();
+                multi = multi.peek(peekConsumer::accept);
 
             } else if (stage instanceof Stage.SubscriberStage) {
                 //Subscribe to stream
                 Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
-                Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
-                single = multi.collect(new io.helidon.common.reactive.Collector() {
-                    @Override
-                    public void collect(Object item) {
-                        subscriber.onNext(item);
-                    }
-
-                    @Override
-                    public Object value() {
-                        return null;
-                    }
-                });
+                Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
+                this.completableFuture = new CompletableFuture<>();
+                CompletionSubscriber completionSubscriber = CompletionSubscriber.of(subscriber, completableFuture);
+                multi.subscribe(HybridSubscriber.from(completionSubscriber));
 
             } else if (stage instanceof Stage.Collect) {
                 //Collect stream
                 Stage.Collect stageFilter = (Stage.Collect) stage;
-                Collector collector = (Collector) stageFilter.getCollector();
-                single = multi.collect(new io.helidon.common.reactive.Collector() {
+                Collector collector = (Collector) stageFilter.getCollector();
+                multi.collect(new io.helidon.common.reactive.Collector() {
                     @Override
-                    public void collect(Object item) {
+                    public void collect(T item) {
                         collector.finisher().apply(item);
                     }
 
                     @Override
-                    public Object value() {
+                    public T value() {
                         return null;
                     }
                 });
@@ -123,12 +118,12 @@ public Object value() {
     }
 
     @Override
-    public BinaryOperator> combiner() {
+    public BinaryOperator> combiner() {
         return (a, b) -> null;
     }
 
     @Override
-    public Function, CompletionStage> finisher() {
+    public Function, CompletionStage> finisher() {
         return t -> toCompletableStage();
     }
 
@@ -137,15 +132,7 @@ public Set characteristics() {
         return new HashSet<>(Collections.singletonList(Characteristics.IDENTITY_FINISH));
     }
 
-    public Multi getMulti() {
-        return this.multi;
-    }
-
-    public Single getSingle() {
-        return this.single;
-    }
-
-    public CompletionStage toCompletableStage() {
-        return this.single != null ? single.toStage() : null;
+    public CompletionStage toCompletableStage() {
+        return completableFuture;
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
new file mode 100644
index 00000000000..65b3271daaf
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive.hybrid;
+
+import io.helidon.common.reactive.Flow;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+public class HybridPublisher implements Flow.Publisher, Publisher {
+
+    private Flow.Publisher flowPublisher;
+    private Publisher reactivePublisher;
+
+    private HybridPublisher(Flow.Publisher flowPublisher) {
+        this.flowPublisher = flowPublisher;
+    }
+
+    private HybridPublisher(Publisher reactivePublisher) {
+        this.reactivePublisher = reactivePublisher;
+    }
+
+    public static  HybridPublisher from(Publisher publisher) {
+        return new HybridPublisher(publisher);
+    }
+
+    public static  HybridPublisher from(Flow.Publisher publisher) {
+        return new HybridPublisher(publisher);
+    }
+
+    @Override
+    public void subscribe(Flow.Subscriber subscriber) {
+        reactivePublisher.subscribe(HybridSubscriber.from(subscriber));
+    }
+
+    @Override
+    public void subscribe(Subscriber subscriber) {
+       flowPublisher.subscribe(HybridSubscriber.from(subscriber));
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
new file mode 100644
index 00000000000..7f8d071ed05
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive.hybrid;
+
+import io.helidon.common.reactive.Flow;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.security.InvalidParameterException;
+
+public class HybridSubscriber implements Flow.Subscriber, Subscriber {
+
+    private Flow.Subscriber flowSubscriber;
+    private Subscriber reactiveSubscriber;
+
+    private HybridSubscriber(Flow.Subscriber subscriber) {
+        this.flowSubscriber = subscriber;
+    }
+
+    private HybridSubscriber(Subscriber subscriber) {
+        this.reactiveSubscriber = subscriber;
+    }
+
+    public static  HybridSubscriber from(Flow.Subscriber subscriber) {
+        return new HybridSubscriber(subscriber);
+    }
+
+    public static  HybridSubscriber from(Subscriber subscriber) {
+        return new HybridSubscriber(subscriber);
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
+    }
+
+    @Override
+    public void onNext(T item) {
+        if (flowSubscriber != null) {
+            flowSubscriber.onNext(item);
+        } else if (reactiveSubscriber != null) {
+            reactiveSubscriber.onNext(item);
+        } else {
+            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
+        }
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        if (flowSubscriber != null) {
+            flowSubscriber.onError(throwable);
+        } else if (reactiveSubscriber != null) {
+            reactiveSubscriber.onError(throwable);
+        } else {
+            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
+        }
+    }
+
+    @Override
+    public void onComplete() {
+        if (flowSubscriber != null) {
+            flowSubscriber.onComplete();
+        } else if (reactiveSubscriber != null) {
+            reactiveSubscriber.onComplete();
+        } else {
+            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
+        }
+    }
+
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
new file mode 100644
index 00000000000..151475a8aae
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive.hybrid;
+
+import io.helidon.common.reactive.Flow;
+import org.reactivestreams.Subscription;
+
+import java.security.InvalidParameterException;
+
+public class HybridSubscription implements Flow.Subscription, Subscription {
+
+    Flow.Subscription flowSubscription;
+    Subscription reactiveSubscription;
+
+    private HybridSubscription(Flow.Subscription flowSubscription) {
+        this.flowSubscription = flowSubscription;
+    }
+
+    private HybridSubscription(Subscription reactiveSubscription) {
+        this.reactiveSubscription = reactiveSubscription;
+    }
+
+    public static HybridSubscription from(Flow.Subscription subscription) {
+        return new HybridSubscription(subscription);
+    }
+
+    public static HybridSubscription from(Subscription subscription) {
+        return new HybridSubscription(subscription);
+    }
+
+    @Override
+    public void request(long n) {
+        if (flowSubscription != null) {
+            flowSubscription.request(n);
+        } else if (reactiveSubscription != null) {
+            reactiveSubscription.request(n);
+        } else {
+            throw new InvalidParameterException("Hybrid subscription has no subscription");
+        }
+    }
+
+    @Override
+    public void cancel() {
+        if (flowSubscription != null) {
+            flowSubscription.cancel();
+        } else if (reactiveSubscription != null) {
+            reactiveSubscription.cancel();
+        } else {
+            throw new InvalidParameterException("Hybrid subscription has no subscription");
+        }
+    }
+}
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
new file mode 100644
index 00000000000..786e72f3241
--- /dev/null
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.function.Consumer;
+
+public class ConsumableSubscriber implements Subscriber {
+
+    private Consumer onNext;
+    private Subscription subscription;
+    private Long chunkSize = 20L;
+    private Long chunkPosition = 0L;
+
+    public ConsumableSubscriber(Consumer onNext) {
+        this.onNext = onNext;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        this.subscription = s;
+        //First chunk request
+        subscription.request(chunkSize);
+    }
+
+    @Override
+    public void onNext(T o) {
+        onNext.accept(o);
+        incrementAndCheckChunkPosition();
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        throw new RuntimeException(t);
+    }
+
+    @Override
+    public void onComplete() {
+    }
+
+    private void incrementAndCheckChunkPosition() {
+        chunkPosition++;
+        if (chunkPosition >= chunkSize) {
+            chunkPosition = 0L;
+            subscription.request(chunkSize);
+        }
+    }
+}
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
new file mode 100644
index 00000000000..9711a75f59a
--- /dev/null
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class EngineTest {
+    @Test
+    void fixedItemsWithMap() {
+        AtomicInteger sum = new AtomicInteger();
+        ReactiveStreams
+                .of("10", "20", "30")
+                .map(a -> a.replaceAll("0", ""))
+                .map(Integer::parseInt)
+                .buildRs()
+                .subscribe(new ConsumableSubscriber<>(sum::addAndGet));
+        assertEquals(1 + 2 + 3, sum.get());
+    }
+
+    @Test
+    void fixedItemsWithFilter() {
+        AtomicInteger sum = new AtomicInteger();
+        ReactiveStreams.of(1, 2, 3, 4, 5)
+                .filter(x -> (x % 2) == 0)
+                .buildRs()
+                .subscribe(new ConsumableSubscriber<>(sum::addAndGet));
+        assertTrue((sum.get() % 2) == 0);
+    }
+
+    @Test
+    void publisherWithMapAndPeekAndFilter() {
+        AtomicInteger peekSum = new AtomicInteger();
+        AtomicInteger sum = new AtomicInteger();
+        IntSequencePublisher intSequencePublisher = new IntSequencePublisher(10);
+
+        ReactiveStreams.fromPublisher(intSequencePublisher)
+                .filter(x -> (x % 2) == 0)
+                .peek(peekSum::addAndGet)
+                .map(String::valueOf)
+                .map(s -> s + "0")
+                .map(Integer::parseInt)
+                .buildRs()
+                .subscribe(new ConsumableSubscriber<>(sum::addAndGet));
+
+        assertEquals(2 + 4 + 6 + 8 + 10, peekSum.get());
+        assertEquals(20 + 40 + 60 + 80 + 100, sum.get());
+    }
+
+    @Test
+    void fromTo() throws ExecutionException, InterruptedException, TimeoutException {
+        AtomicInteger sum = new AtomicInteger();
+        IntSequencePublisher publisher = new IntSequencePublisher(10);
+        StringBuilder beforeFilter = new StringBuilder();
+        StringBuilder afterFilter = new StringBuilder();
+        ReactiveStreams
+                .fromPublisher(publisher)
+                .map(String::valueOf)
+                .map(i -> i + "-")
+                .peek(beforeFilter::append)
+                .map(s -> s.replaceAll("-", ""))
+                .map(Integer::parseInt)
+                .filter(i -> i <= 5)
+                .peek(afterFilter::append)
+                .to(ReactiveStreams.fromSubscriber(new ConsumableSubscriber<>(sum::addAndGet)))
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals("1-2-3-4-5-6-7-8-9-10-", beforeFilter.toString());
+        assertEquals("12345", afterFilter.toString());
+        assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
+    }
+}
\ No newline at end of file
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
new file mode 100644
index 00000000000..6c5ce8fffff
--- /dev/null
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class IntSequencePublisher implements Publisher, Subscription {
+
+    private AtomicBoolean closed = new AtomicBoolean(false);
+    private AtomicInteger sequence = new AtomicInteger(0);
+    private Subscriber subscriber;
+    private int count;
+
+    public IntSequencePublisher(int count) {
+        this.count = count;
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        subscriber = s;
+        subscriber.onSubscribe(this);
+    }
+
+    @Override
+    public void request(long n) {
+        for (long i = 0; i < n
+                && !closed.get()
+                && sequence.get() < count; n++) {
+            subscriber.onNext(sequence.incrementAndGet());
+            if(sequence.get() >= count){
+                subscriber.onComplete();
+            }
+        }
+    }
+
+    @Override
+    public void cancel() {
+        closed.set(true);
+    }
+}

From c93ae8e29c8018d62099c62955c1b77d12242d36 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 13 Nov 2019 16:03:23 +0100
Subject: [PATCH 12/66] Passing 11/14 tck tests

Signed-off-by: Daniel Kec 
---
 .../messaging/channel/IncomingMethod.java     |  27 +++-
 .../messaging/reactive/UnwrapProcessor.java   | 117 ++++++++++++++++++
 .../messaging/AbstractCDITest.java            |   8 ++
 .../messaging/AssertThrowException.java       |  30 +++++
 .../inner/AbstractShapeTestBean.java          |  37 ++++++
 .../BadSignaturePublisherPayloadBean.java     |  45 +++++++
 .../messaging/inner/InnerChannelTest.java     |  36 ++++--
 .../NotConnectedIncommingChannelBean.java     |   2 +
 .../NotConnectedOutgoingChannelBean.java      |   2 +
 .../inner/PublisherPayloadV1Bean.java         |  42 +++++++
 .../inner/PublisherPayloadV3Bean.java         |  45 +++++++
 .../inner/PublisherPayloadV4Bean.java         |  46 +++++++
 .../inner/PublisherPayloadV5Bean.java         |  48 +++++++
 .../inner/PublisherPayloadV6Bean.java         |  48 +++++++
 .../PublisherSubscriberBuilderV1Bean.java     |  44 +++++++
 .../PublisherSubscriberBuilderV2Bean.java     |  44 +++++++
 .../inner/PublisherSubscriberV1Bean.java      |  41 ++++++
 .../inner/PublisherSubscriberV2Bean.java      |  43 +++++++
 .../reactive/UnwrapProcessorTest.java         |  70 +++++++++++
 19 files changed, 764 insertions(+), 11 deletions(-)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertThrowException.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/BadSignaturePublisherPayloadBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index b603c036c85..8af1f957892 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -19,6 +19,7 @@
 
 import io.helidon.config.Config;
 import io.helidon.microprofile.messaging.reactive.InternalSubscriber;
+import io.helidon.microprofile.messaging.reactive.UnwrapProcessor;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Subscriber;
@@ -28,6 +29,7 @@
 import javax.enterprise.inject.spi.DeploymentException;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
 import java.util.concurrent.CompletionStage;
 import java.util.logging.Logger;
 
@@ -62,13 +64,14 @@ public void init(BeanManager beanManager, Config config) {
             try {
                 switch (type) {
                     case INCOMING_VOID_2_SUBSCRIBER:
-                        subscriber = (Subscriber) method.invoke(beanInstance);
+                        subscriber = UnwrapProcessor.of(this.method, (Subscriber) method.invoke(beanInstance));
                         break;
                     case INCOMING_VOID_2_SUBSCRIBER_BUILDER:
-                        subscriber = ((SubscriberBuilder) method.invoke(beanInstance)).build();
+                        subscriber = UnwrapProcessor.of(this.method, ((SubscriberBuilder) method.invoke(beanInstance)).build());
                         break;
                     default:
-                        throw new DeploymentException("Unsupported method signature " + method);
+                        //TODO: Implement rest of the method signatures supported by spec
+                        throw new UnsupportedOperationException("Not implemented yet " + type);
                 }
             } catch (IllegalAccessException | InvocationTargetException e) {
                 throw new RuntimeException(e);
@@ -85,7 +88,15 @@ public Subscriber getSubscriber() {
 
     protected void resolveSignatureType() {
         Class returnType = this.method.getReturnType();
-        Class parameterType = this.method.getParameterTypes()[0];
+        Class parameterType;
+        if (this.method.getParameterTypes().length == 1) {
+            parameterType = this.method.getParameterTypes()[0];
+        } else if (this.method.getParameterTypes().length == 0) {
+            parameterType = Void.TYPE;
+        } else {
+            throw new DeploymentException("Unsupported parameters on incoming method " + method);
+        }
+
         if (Void.TYPE.equals(parameterType)) {
             if (Subscriber.class.equals(returnType)) {
                 this.type = Type.INCOMING_VOID_2_SUBSCRIBER;
@@ -97,8 +108,16 @@ protected void resolveSignatureType() {
                 this.type = Type.INCOMING_MSG_2_COMPLETION_STAGE;
             } else if (Void.TYPE.equals(returnType)) {
                 this.type = Type.INCOMING_MSG_2_VOID;
+            } else {
+                //TODO: Remove when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
+                // see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
+                this.type = Type.INCOMING_MSG_2_VOID;
             }
         }
+
+        if (Objects.isNull(type)) {
+            throw new DeploymentException("Unsupported incoming method signature " + method);
+        }
     }
 
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
new file mode 100644
index 00000000000..941b0db9821
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.reactive;
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.security.InvalidParameterException;
+
+/**
+ * Unwrap Message payload if incoming method Publisher or Publisher builder
+ * has generic return type different than Message
+ * 

+ * This is not necessary with Helidon reactive stream engine, but small-rye would fail
+ */
+public class UnwrapProcessor implements Processor {
+
+    private Method method;
+    private Subscriber subscriber;
+
+    UnwrapProcessor() {
+    }
+
+    public static UnwrapProcessor of(Method method, Subscriber subscriber) {
+        UnwrapProcessor unwrapProcessor = new UnwrapProcessor();
+        unwrapProcessor.subscribe(subscriber);
+        unwrapProcessor.setMethod(method);
+        return unwrapProcessor;
+    }
+
+    Object unwrap(Object o) {
+        if (o instanceof Message && !isTypeMessage(method)) {
+            Message message = (Message) o;
+            return message.getPayload();
+        } else {
+            return o;
+        }
+    }
+
+    static boolean isTypeMessage(Method method) {
+        Type returnType = method.getGenericReturnType();
+        ParameterizedType parameterizedType = (ParameterizedType) returnType;
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+        if (SubscriberBuilder.class.equals(method.getReturnType())) {
+            if (actualTypeArguments.length != 2) {
+                throw new DeploymentException("Invalid method return type " + method);
+            }
+            return isMessageType(actualTypeArguments[0]);
+        } else if (Subscriber.class.equals(method.getReturnType())) {
+            if (actualTypeArguments.length != 1) {
+                throw new DeploymentException("Invalid method return type " + method);
+            }
+            return isMessageType(actualTypeArguments[0]);
+        }
+        throw new InvalidParameterException("Only methods with Subscriber or Subscriber builder should be unwrapped by processor");
+    }
+
+    private static boolean isMessageType(Type type) {
+        if (type instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            return Message.class.equals(parameterizedType.getRawType());
+        }
+        return false;
+    }
+
+    @Override
+    public void subscribe(Subscriber subscriber) {
+        this.subscriber = subscriber;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        subscriber.onSubscribe(s);
+    }
+
+    @Override
+    public void onNext(Object o) {
+        subscriber.onNext(unwrap(o));
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+    }
+
+    public void setMethod(Method method) {
+        this.method = method;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index d210efffb43..59ffb46be3d 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -39,6 +39,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
@@ -164,6 +165,13 @@ public Class[] getClazzes() {
             return clazzes;
         }
 
+        public Optional> getExpectedThrowable() {
+            return Arrays.stream(clazzes)
+                    .filter(c -> c.getAnnotation(AssertThrowException.class) != null)
+                    .map(c -> c.getAnnotation(AssertThrowException.class).value())
+                    .findFirst();
+        }
+
         public List> getCountableBeanClasses() {
             return Arrays.stream(clazzes)
                     .filter(CountableTestBean.class::isAssignableFrom)
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertThrowException.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertThrowException.java
new file mode 100644
index 00000000000..06962e6dc8f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertThrowException.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Target({TYPE})
+@Retention(RUNTIME)
+public @interface AssertThrowException {
+    Class value();
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
new file mode 100644
index 00000000000..5aa7952b4d2
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+
+public abstract class AbstractShapeTestBean implements CountableTestBean {
+
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/BadSignaturePublisherPayloadBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/BadSignaturePublisherPayloadBean.java
new file mode 100644
index 00000000000..af325a890f7
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/BadSignaturePublisherPayloadBean.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.AssertThrowException;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+//TODO: Uncomment when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
+//@AssertThrowException(Exception.class)
+public class BadSignaturePublisherPayloadBean extends AbstractShapeTestBean {
+
+    @Outgoing("string-payload")
+    public Publisher> sourceForStringPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("string-payload")
+    public String consumePayloadsAndReturnSomething(String payload) {
+        testLatch.countDown();
+        return payload;
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 9bd3d81fe36..4239d1ad26b 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -27,6 +27,7 @@
 import javax.enterprise.inject.spi.DeploymentException;
 
 import java.util.Collections;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -40,23 +41,44 @@ public void setUp() {
 
     static Stream testCaseSource() {
         return Stream.of(
+                //Positive tests
+                CdiTestCase.from(PublisherPayloadV6Bean.class),
+                CdiTestCase.from(PublisherPayloadV5Bean.class),
+                CdiTestCase.from(PublisherPayloadV4Bean.class),
+                CdiTestCase.from(PublisherPayloadV3Bean.class),
+                CdiTestCase.from(PublisherPayloadV1Bean.class),
+                CdiTestCase.from(PublisherSubscriberBuilderV2Bean.class),
+                CdiTestCase.from(PublisherSubscriberBuilderV1Bean.class),
+                CdiTestCase.from(PublisherSubscriberV2Bean.class),
+                CdiTestCase.from(PublisherSubscriberV1Bean.class),
                 CdiTestCase.from(InternalChannelsBean.class),
                 CdiTestCase.from(InnerProcessorBean.class),
                 CdiTestCase.from(MultipleProcessorBean.class),
                 CdiTestCase.from(MultipleTypeProcessorChainBean.class),
-                CdiTestCase.from(PrimitiveProcessorBean.class)
+                CdiTestCase.from(PrimitiveProcessorBean.class),
+
+                //Negative tests
+                CdiTestCase.from(NotConnectedIncommingChannelBean.class),
+                CdiTestCase.from(NotConnectedOutgoingChannelBean.class),
+                CdiTestCase.from(BadSignaturePublisherPayloadBean.class)
         );
     }
 
     @ParameterizedTest
     @MethodSource("testCaseSource")
     void innerChannelBeanTest(CdiTestCase testCase) {
-        cdiContainer = startCdiContainer(Collections.emptyMap(), testCase.getClazzes());
-        testCase.getCountableBeanClasses().forEach(c -> {
-            CountableTestBean countableTestBean = CDI.current().select(c).get();
-            // Wait till all messages are delivered
-            assertAllReceived(countableTestBean);
-        });
+        Optional> expectedThrowable = testCase.getExpectedThrowable();
+        if (expectedThrowable.isPresent()) {
+            assertThrows(expectedThrowable.get(), () ->
+                    cdiContainer = startCdiContainer(Collections.emptyMap(), testCase.getClazzes()));
+        } else {
+            cdiContainer = startCdiContainer(Collections.emptyMap(), testCase.getClazzes());
+            testCase.getCountableBeanClasses().forEach(c -> {
+                CountableTestBean countableTestBean = CDI.current().select(c).get();
+                // Wait till all messages are delivered
+                assertAllReceived(countableTestBean);
+            });
+        }
     }
 
     @Test
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
index 1db13ef3623..0624d61c909 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedIncommingChannelBean.java
@@ -16,11 +16,13 @@
 
 package io.helidon.microprofile.messaging.inner;
 
+import io.helidon.microprofile.messaging.AssertThrowException;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 
 import javax.enterprise.context.ApplicationScoped;
 
 @ApplicationScoped
+@AssertThrowException(Exception.class)
 public class NotConnectedIncommingChannelBean {
 
     @Incoming("not-existing-channel")
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
index 90d18e71b56..7ce4a9e91fb 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/NotConnectedOutgoingChannelBean.java
@@ -16,6 +16,7 @@
 
 package io.helidon.microprofile.messaging.inner;
 
+import io.helidon.microprofile.messaging.AssertThrowException;
 import io.helidon.microprofile.reactive.MultiRS;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.reactivestreams.Publisher;
@@ -23,6 +24,7 @@
 import javax.enterprise.context.ApplicationScoped;
 
 @ApplicationScoped
+@AssertThrowException(Exception.class)
 public class NotConnectedOutgoingChannelBean {
 
     @Outgoing("not-existing-channel")
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java
new file mode 100644
index 00000000000..1e562cc2edf
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherPayloadV1Bean extends AbstractShapeTestBean {
+
+    @Outgoing("void-payload")
+    public Publisher> sourceForVoidPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("void-payload")
+    public void consumePayload(String payload) {
+        testLatch.countDown();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java
new file mode 100644
index 00000000000..4c2d2b79e06
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class PublisherPayloadV3Bean extends AbstractShapeTestBean {
+
+    @Outgoing("cs-void-message")
+    public Publisher> sourceForCsVoidMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("cs-void-message")
+    public CompletionStage consumeMessageAndReturnCompletionStageOfVoid(Message message) {
+        return CompletableFuture.runAsync(() -> testLatch.countDown(), Executors.newSingleThreadExecutor());
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java
new file mode 100644
index 00000000000..9b4eff0288f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class PublisherPayloadV4Bean extends AbstractShapeTestBean {
+
+    @Outgoing("cs-void-payload")
+    public Publisher> sourceForCsVoidPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("cs-void-payload")
+    public CompletionStage consumePayloadAndReturnCompletionStageOfVoid(String payload) {
+        testLatch.countDown();
+        return CompletableFuture.runAsync(() -> testLatch.countDown(), Executors.newSingleThreadExecutor());
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java
new file mode 100644
index 00000000000..743371cccac
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class PublisherPayloadV5Bean extends AbstractShapeTestBean {
+
+    @Outgoing("cs-string-message")
+    public Publisher> sourceForCsStringMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("cs-string-message")
+    public CompletionStage consumeMessageAndReturnCompletionStageOfString(Message message) {
+        return CompletableFuture.supplyAsync(() -> {
+            testLatch.countDown();
+            return "something";
+        }, Executors.newSingleThreadExecutor());
+    }
+    
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java
new file mode 100644
index 00000000000..bc26e9d9d76
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class PublisherPayloadV6Bean extends AbstractShapeTestBean {
+
+    @Outgoing("cs-string-payload")
+    public Publisher> sourceForCsStringPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("cs-string-payload")
+    public CompletionStage consumePayloadAndReturnCompletionStageOfString(String payload) {
+        return CompletableFuture.supplyAsync(() -> {
+            testLatch.countDown();
+            return "something";
+        }, Executors.newSingleThreadExecutor());
+    }
+    
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java
new file mode 100644
index 00000000000..4e590372127
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherSubscriberBuilderV1Bean extends AbstractShapeTestBean {
+
+    @Outgoing("subscriber-builder-message")
+    public Publisher> sourceForSubscriberBuilderMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("subscriber-builder-message")
+    public SubscriberBuilder, Void> subscriberBuilderOfMessages() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> testLatch.countDown());
+    }
+
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java
new file mode 100644
index 00000000000..7504bb76e3b
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherSubscriberBuilderV2Bean extends AbstractShapeTestBean {
+
+    @Outgoing("subscriber-builder-payload")
+    public Publisher> sourceForSubscriberBuilderPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("subscriber-builder-payload")
+    public SubscriberBuilder subscriberBuilderOfPayloads() {
+        return ReactiveStreams.builder().forEach(p -> testLatch.countDown());
+    }
+
+
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java
new file mode 100644
index 00000000000..7fa6409ef23
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherSubscriberV1Bean extends AbstractShapeTestBean {
+
+    @Outgoing("subscriber-message")
+    public Publisher> sourceForSubscriberMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("subscriber-message")
+    public Subscriber> subscriberOfMessages() {
+        return ReactiveStreams.>builder().forEach(m -> testLatch.countDown()).build();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java
new file mode 100644
index 00000000000..0948f821993
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherSubscriberV2Bean extends AbstractShapeTestBean {
+
+    @Outgoing("subscriber-payload")
+    public Publisher> sourceForSubscribePayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+    @Incoming("subscriber-payload")
+    public Subscriber subscriberOfPayloads() {
+        return ReactiveStreams.builder().forEach(p -> testLatch.countDown()).build();
+    }
+
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
new file mode 100644
index 00000000000..ec8f98ac12d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.reactive;
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.reactivestreams.Subscriber;
+
+import java.lang.reflect.Method;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class UnwrapProcessorTest {
+
+    public SubscriberBuilder testMethodSubscriberBuilderString() {
+        return ReactiveStreams.builder().forEach(System.out::println);
+    }
+
+    public SubscriberBuilder, Void> testMethodSubscriberBuilderMessage() {
+        return ReactiveStreams.>builder().forEach(System.out::println);
+    }
+
+    public Subscriber testMethodSubscriberString() {
+        return ReactiveStreams.builder().forEach(System.out::println).build();
+    }
+
+    public Subscriber> testMethodSubscriberMessage() {
+        return ReactiveStreams.>builder().forEach(System.out::println).build();
+    }
+
+    static Stream methodSource() {
+        return Stream.of(UnwrapProcessorTest.class.getDeclaredMethods())
+                .filter(m -> m.getName().startsWith("testMethod"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("methodSource")
+    void innerChannelBeanTest(Method method) {
+        UnwrapProcessor unwrapProcessor = new UnwrapProcessor();
+        unwrapProcessor.setMethod(method);
+        Object unwrappedValue = unwrapProcessor.unwrap(Message.of("test"));
+        if (method.getName().endsWith("Message")) {
+            assertTrue(UnwrapProcessor.isTypeMessage(method));
+            assertTrue(unwrappedValue instanceof Message);
+        } else {
+            assertFalse(UnwrapProcessor.isTypeMessage(method));
+            assertFalse(unwrappedValue instanceof Message);
+        }
+    }
+}

From aeb3613596e10811af0e3966c143430424bc94d2 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 16 Nov 2019 19:23:54 +0100
Subject: [PATCH 13/66] Reactive streams Multi integration

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  17 +-
 .../common/reactive/FilterProcessor.java      |   5 +
 .../common/reactive/LimitProcessor.java       |  55 +++++++
 .../io/helidon/common/reactive/Multi.java     |  12 ++
 .../reactive/MultiMappingProcessor.java       |   5 +
 .../common/reactive/PeekProcessor.java        |  12 ++
 .../microprofile/messaging/MessageUtils.java  |   8 +-
 .../messaging/channel/AbstractChannel.java    |  39 ++++-
 .../messaging/channel/IncomingMethod.java     |   6 +-
 .../messaging/channel/OutgoingMethod.java     |  55 +++++--
 .../messaging/reactive/InternalPublisher.java |  36 ++++-
 .../messaging/reactive/UnwrapProcessor.java   |  10 +-
 .../inner/CompletionStageV1Bean.java          |  55 +++++++
 .../messaging/inner/InnerChannelTest.java     |  16 +-
 .../messaging/inner/PullForEachBean.java      |  47 ++++++
 .../reactive/CompletionSubscriber.java        |  15 +-
 .../reactive/HelidonReactiveStreamEngine.java |  70 +--------
 .../HelidonSubscriberWithCompletionStage.java | 147 ++++++++++++++++++
 .../reactive/MultiStagesCollector.java        |  74 ++++++---
 .../reactive/hybrid/HybridProcessor.java      | 116 ++++++++++++++
 .../reactive/hybrid/HybridSubscriber.java     |  16 +-
 .../reactive/ConsumableSubscriber.java        |  30 ++--
 .../microrofile/reactive/EngineTest.java      |  41 ++++-
 .../reactive/IntSequencePublisher.java        |  13 +-
 24 files changed, 731 insertions(+), 169 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/CompletionStageV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PullForEachBean.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 969c1734f24..79b87d424ed 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -57,6 +57,11 @@ public final void request(long n) {
     @Override
     public final void cancel() {
         subscriber.cancel();
+        try {
+            hookOnCancel(subscription);
+        } catch (Throwable ex) {
+            onError(ex);
+        }
     }
 
     @Override
@@ -107,6 +112,7 @@ public void subscribe(Subscriber s) {
 
     /**
      * Submit an item to the subscriber.
+     *
      * @param item item to be submitted
      */
     protected void submit(U item) {
@@ -128,6 +134,7 @@ protected void submit(U item) {
 
     /**
      * Hook for {@link Subscriber#onNext(java.lang.Object)}.
+     *
      * @param item next item
      */
     protected void hookOnNext(T item) {
@@ -135,6 +142,7 @@ protected void hookOnNext(T item) {
 
     /**
      * Hook for {@link Subscriber#onError(java.lang.Throwable)}.
+     *
      * @param error error received
      */
     protected void hookOnError(Throwable error) {
@@ -146,8 +154,15 @@ protected void hookOnError(Throwable error) {
     protected void hookOnComplete() {
     }
 
+    /**
+     * Hook for {@link Flow.Subscription#cancel()}.
+     */
+    protected void hookOnCancel(Flow.Subscription subscription) {
+    }
+
     /**
      * Subscribe the subscriber after the given delegate publisher.
+     *
      * @param delegate delegate publisher
      */
     protected final void doSubscribe(Publisher delegate) {
@@ -181,7 +196,7 @@ private void completeOnError(Subscriber sub, Throwable ex) {
         sub.onError(ex);
     }
 
-    private void tryComplete() {
+    protected void tryComplete() {
         if (ready.get() && !subscriber.isClosed()) {
             if (error != null) {
                 subscriber.close(sub -> completeOnError(sub, error));
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 1ea122b023a..00e39aa762c 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -32,6 +32,11 @@ public FilterProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
     @Override
     protected void hookOnNext(T item) {
         if (predicate.test(item)) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
new file mode 100644
index 00000000000..d2f3ab3b10b
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Invoke supplied consumer for every item in the stream
+ *
+ * @param  both input/output type
+ */
+public class LimitProcessor extends BaseProcessor implements Multi {
+
+    private final AtomicLong counter;
+
+    public LimitProcessor(Long limit) {
+        counter = new AtomicLong(limit);
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        if (0 < counter.getAndDecrement()) {
+            submit(item);
+        } else {
+            tryComplete();
+        }
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    public String toString() {
+        return "LimitProcessor{" +
+                "counter=" + counter +
+                '}';
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 5c17bc8ae9f..ae131da1b4d 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -71,6 +71,18 @@ default  Multi filter(Predicate predicate) {
         return processor;
     }
 
+    /**
+     * Limit stream to allow only specified number of items to pass
+     *
+     * @param supplier with expected number of items to be produced
+     * @return Multi
+     */
+    default  Multi limit(Long limit) {
+        LimitProcessor processor = new LimitProcessor(limit);
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Collect the items of this {@link Multi} instance into a {@link Single} of {@link List}.
      *
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
index 2fed3725f9d..983544329f6 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
@@ -34,6 +34,11 @@ final class MultiMappingProcessor extends BaseProcessor implements M
         this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
     }
 
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
     @Override
     protected void hookOnNext(T item) {
         U value = mapper.map(item);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
index 9ed1a876900..e9890bf5ab7 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
@@ -37,4 +37,16 @@ protected void hookOnNext(T item) {
         consumer.accept(item);
         submit(item);
     }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    public String toString() {
+        return "PeekProcessor{" +
+                "consumer=" + consumer +
+                '}';
+    }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
index 59115981bcf..dd4509ae06f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -21,7 +21,11 @@
 
 public class MessageUtils {
     public static Object unwrap(Object value, Class type) {
-        if (type.equals(Message.class)) {
+        return unwrap(value, type.equals(Message.class));
+    }
+
+    public static Object unwrap(Object value, Boolean isMessageType) {
+        if (isMessageType) {
             if (value instanceof Message) {
                 return value;
             } else {
@@ -30,8 +34,6 @@ public static Object unwrap(Object value, Class type) {
         } else {
             if (value instanceof Message) {
                 return ((Message) value).getPayload();
-            } else if (type.isInstance(value)) {
-                return value;
             } else {
                 return value;
             }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
index 48df7bd472a..bf40f2c4eb8 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
@@ -169,8 +169,45 @@ public enum Type {
          * 
CompletionStage<?> method(Message<I>msg)

          * 
CompletionStage<?> method(I payload)

          */
-        INCOMING_MSG_2_COMPLETION_STAGE(false);
+        INCOMING_MSG_2_COMPLETION_STAGE(false),
 
+        /**
+         * Invoke at: assembly time
+         * 
Publisher<Message<U>> method()

+         * 
Publisher<U> method()

+         */
+        OUTGOING_VOID_2_PUBLISHER(true),
+
+        /**
+         * Invoke at: assembly time
+         * 
PublisherBuilder<Message<U>> method()

+         * 
PublisherBuilder<U> method()

+         */
+        OUTGOING_VOID_2_PUBLISHER_BUILDER(true),
+
+        /**
+         * Invoke at: Each request made by subscriber
+         * 
Message<U> method()

+         * 
U method()

+         * 

+         * Produces an infinite stream of Message associated with the
+         * channel channel. The result is a CompletionStage. The method should not be
+         * called by the reactive messaging implementation until the CompletionStage
+         * returned previously is completed.
+         */
+        OUTGOING_VOID_2_MSG(false),
+
+        /**
+         * Invoke at: Each request made by subscriber
+         * 
CompletionStage<Message<U>> method()

+         * 
CompletionStage<U> method()

+         * 

+         * Produces an infinite stream of Message associated with the
+         * channel channel. The result is a CompletionStage. The method should not be
+         * called by the reactive messaging implementation until the CompletionStage
+         * returned previously is completed.
+         */
+        OUTGOING_VOID_2_COMPLETION_STAGE(false);
 
         private boolean invokeAtAssembly;
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 8af1f957892..fde3f2d34bf 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -60,7 +60,6 @@ void validate() {
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
         if (type.isInvokeAtAssembly()) {
-            // Incoming methods returning custom subscriber
             try {
                 switch (type) {
                     case INCOMING_VOID_2_SUBSCRIBER:
@@ -70,14 +69,13 @@ public void init(BeanManager beanManager, Config config) {
                         subscriber = UnwrapProcessor.of(this.method, ((SubscriberBuilder) method.invoke(beanInstance)).build());
                         break;
                     default:
-                        //TODO: Implement rest of the method signatures supported by spec
-                        throw new UnsupportedOperationException("Not implemented yet " + type);
+                        throw new UnsupportedOperationException("Not implemented signature " + type);
                 }
             } catch (IllegalAccessException | InvocationTargetException e) {
                 throw new RuntimeException(e);
             }
         } else {
-            // Create brand new subscriber
+            // Invoke on each message subscriber
             subscriber = new InternalSubscriber(method, beanInstance);
         }
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
index e9d0bb1c5e6..ca055ceae1d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -28,6 +28,8 @@
 import javax.enterprise.inject.spi.DeploymentException;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
 import java.util.logging.Logger;
 
 public class OutgoingMethod extends AbstractChannel {
@@ -39,23 +41,30 @@ public class OutgoingMethod extends AbstractChannel {
     public OutgoingMethod(AnnotatedMethod method, ChannelRouter router) {
         super(method.getJavaMember(), router);
         super.outgoingChannelName = method.getAnnotation(Outgoing.class).value();
+        resolveSignatureType();
     }
 
     @Override
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
-        // TODO: Rewrite with enum
-        try {
-            Class returnType = method.getReturnType();
-            if (returnType.equals(Publisher.class)) {
-                publisher = (Publisher) method.invoke(beanInstance);
-            } else if (returnType.equals(PublisherBuilder.class)) {
-                publisher = ((PublisherBuilder) method.invoke(beanInstance)).buildRs();
-            } else {
-                publisher = new InternalPublisher(method, beanInstance);
+        if (type.isInvokeAtAssembly()) {
+            try {
+                switch (type) {
+                    case OUTGOING_VOID_2_PUBLISHER:
+                        publisher = (Publisher) method.invoke(beanInstance);
+                        break;
+                    case OUTGOING_VOID_2_PUBLISHER_BUILDER:
+                        publisher = ((PublisherBuilder) method.invoke(beanInstance)).buildRs();
+                        break;
+                    default:
+                        throw new UnsupportedOperationException("Not implemented signature " + type);
+                }
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(e);
             }
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e);
+        } else {
+            // Invoke on each request publisher
+            publisher = new InternalPublisher(method, beanInstance);
         }
     }
 
@@ -73,4 +82,28 @@ public void validate() {
     public Publisher getPublisher() {
         return publisher;
     }
+
+    protected void resolveSignatureType() {
+        Class returnType = this.method.getReturnType();
+        if (this.method.getParameterTypes().length != 0) {
+            throw new DeploymentException("Unsupported parameters on outgoing method " + method);
+        }
+
+        if (Void.class.isAssignableFrom(returnType)) {
+            type = null;
+        } else if (Publisher.class.isAssignableFrom(returnType)) {
+            this.type = Type.OUTGOING_VOID_2_PUBLISHER;
+        } else if (PublisherBuilder.class.isAssignableFrom(returnType)) {
+            this.type = Type.OUTGOING_VOID_2_PUBLISHER_BUILDER;
+        } else if (CompletionStage.class.isAssignableFrom(returnType)) {
+            this.type = Type.OUTGOING_VOID_2_COMPLETION_STAGE;
+        } else {
+            this.type = Type.OUTGOING_VOID_2_MSG;
+        }
+
+        if (Objects.isNull(type)) {
+            throw new DeploymentException("Unsupported outgoing method signature " + method);
+        }
+    }
+
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
index 1852399aa8b..10a987e70ba 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
@@ -19,14 +19,20 @@
 
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
-public class InternalPublisher implements Publisher {
+public class InternalPublisher implements Publisher, Subscription {
 
     private Method method;
     private Object beanInstance;
+    private Subscriber subscriber;
+    private AtomicBoolean closed = new AtomicBoolean(false);
 
     public InternalPublisher(Method method, Object beanInstance) {
         this.method = method;
@@ -35,12 +41,32 @@ public InternalPublisher(Method method, Object beanInstance) {
 
     @Override
     public void subscribe(Subscriber s) {
+        subscriber = s;
+        subscriber.onSubscribe(this);
+    }
+
+    @Override
+    public void request(long n) {
         try {
-            s.onNext(method.invoke(beanInstance));
-            s.onComplete();
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            s.onError(e);
+            for (long i = 0; i < n
+                    && !closed.get(); i++) {
+                Object result = method.invoke(beanInstance);
+                //TODO: Completion stage blocking in the spec seems useless
+                if (result instanceof CompletionStage) {
+                    CompletionStage completionStage = (CompletionStage) result;
+                    subscriber.onNext(completionStage.toCompletableFuture().get());
+                } else {
+                    subscriber.onNext(result);
+                }
+            }
+            subscriber.onComplete();
+        } catch (IllegalAccessException | InvocationTargetException | InterruptedException | ExecutionException e) {
+            subscriber.onError(e);
         }
     }
 
+    @Override
+    public void cancel() {
+        closed.set(true);
+    }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
index 941b0db9821..ebaa740ec56 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.messaging.reactive;
 
+import io.helidon.microprofile.messaging.MessageUtils;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Processor;
@@ -33,8 +34,6 @@
 /**
  * Unwrap Message payload if incoming method Publisher or Publisher builder
  * has generic return type different than Message
- * 

- * This is not necessary with Helidon reactive stream engine, but small-rye would fail
  */
 public class UnwrapProcessor implements Processor {
 
@@ -52,12 +51,7 @@ public static UnwrapProcessor of(Method method, Subscriber subscriber) {
     }
 
     Object unwrap(Object o) {
-        if (o instanceof Message && !isTypeMessage(method)) {
-            Message message = (Message) o;
-            return message.getPayload();
-        } else {
-            return o;
-        }
+        return MessageUtils.unwrap(o, isTypeMessage(method));
     }
 
     static boolean isTypeMessage(Method method) {
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/CompletionStageV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/CompletionStageV1Bean.java
new file mode 100644
index 00000000000..1ccc73cd32a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/CompletionStageV1Bean.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@ApplicationScoped
+public class CompletionStageV1Bean extends AbstractShapeTestBean {
+
+    AtomicInteger testSequence = new AtomicInteger();
+
+    @Outgoing("generator-payload-async")
+    public CompletionStage getPayloadAsync() {
+        return CompletableFuture.supplyAsync(() -> testSequence.incrementAndGet(), Executors.newSingleThreadExecutor());
+    }
+
+//    @Outgoing("generator-payload-async")
+//    public Integer getPayloadAsyncs() {
+//        return testSequence.incrementAndGet();
+//    }
+
+    @Incoming("generator-payload-async")
+    public Subscriber getFromInfiniteAsyncPayloadGenerator() {
+        return ReactiveStreams.builder()
+                .limit(TEST_DATA.size())
+                .forEach(s -> getTestLatch().countDown())
+                .build();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 4239d1ad26b..c329a52e538 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -19,12 +19,10 @@
 
 import io.helidon.microprofile.messaging.AbstractCDITest;
 import io.helidon.microprofile.messaging.CountableTestBean;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
 import javax.enterprise.inject.spi.CDI;
-import javax.enterprise.inject.spi.DeploymentException;
 
 import java.util.Collections;
 import java.util.Optional;
@@ -42,6 +40,8 @@ public void setUp() {
     static Stream testCaseSource() {
         return Stream.of(
                 //Positive tests
+                CdiTestCase.from(PullForEachBean.class),
+                CdiTestCase.from(CompletionStageV1Bean.class),
                 CdiTestCase.from(PublisherPayloadV6Bean.class),
                 CdiTestCase.from(PublisherPayloadV5Bean.class),
                 CdiTestCase.from(PublisherPayloadV4Bean.class),
@@ -80,16 +80,4 @@ void innerChannelBeanTest(CdiTestCase testCase) {
             });
         }
     }
-
-    @Test
-    void notConnectedIncomingChannelTest() {
-        assertThrows(DeploymentException.class, () ->
-                cdiContainer = startCdiContainer(Collections.emptyMap(), NotConnectedIncommingChannelBean.class));
-    }
-
-    @Test
-    void notConnectedOutgoingChannelTest() {
-        assertThrows(DeploymentException.class, () ->
-                cdiContainer = startCdiContainer(Collections.emptyMap(), NotConnectedOutgoingChannelBean.class));
-    }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PullForEachBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PullForEachBean.java
new file mode 100644
index 00000000000..8cb88fac561
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PullForEachBean.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@ApplicationScoped
+public class PullForEachBean extends AbstractShapeTestBean {
+
+    AtomicInteger testSequence = new AtomicInteger();
+
+    @Outgoing("generator-payload-async")
+    public Integer getPayload() {
+        return testSequence.incrementAndGet();
+    }
+
+    @Incoming("generator-payload-async")
+    public Subscriber getFromInfinitePayloadGenerator() {
+        return ReactiveStreams.builder()
+                .limit(TEST_DATA.size())
+                .forEach(s -> getTestLatch().countDown())
+                .build();
+    }
+
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
index 02337a6e0e3..d446b0a4659 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
@@ -51,7 +51,19 @@ public CompletionStage getCompletion() {
 
     @Override
     public void onSubscribe(Subscription s) {
-        subscriber.onSubscribe(s);
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                s.request(n);
+            }
+
+            @Override
+            public void cancel() {
+                s.cancel();
+                //Base processor breaks cancel->onComplete loop, so listen even for downstream call
+                completion.toCompletableFuture().complete(null);
+            }
+        });
     }
 
     @Override
@@ -68,6 +80,7 @@ public void onError(Throwable t) {
     @Override
     public void onComplete() {
         subscriber.onComplete();
+        //Base processor breaks cancel->onComplete loop, so listen even for upstream call
         completion.toCompletableFuture().complete(null);
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 2b0154ae71f..3906fa5c461 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -24,13 +24,9 @@
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
 
 import java.util.Collection;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
-import java.util.function.BiConsumer;
 import java.util.logging.Logger;
 
 public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
@@ -47,67 +43,9 @@ public  Publisher buildPublisher(Graph graph) throws UnsupportedStageExcep
 
     @Override
     public  SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException {
-        Collection stages = graph.getStages();
-        if (stages.size() != 1) {
-            //TODO: Support more than one stage
-            throw new RuntimeException("Exactly one stage is supported for now");
-        }
-        Stage firstStage = stages.iterator().next();
-        if (firstStage instanceof Stage.Collect) {
-            // Foreach
-            Stage.Collect collectStage = (Stage.Collect) firstStage;
-            CompletableFuture completableFuture = new CompletableFuture<>();
-            return new SubscriberWithCompletionStage() {
-                @Override
-                public CompletionStage getCompletion() {
-                    return completableFuture;
-                }
-
-                @Override
-                public Subscriber getSubscriber() {
-                    return new Subscriber() {
-
-                        private Subscription subscription;
-                        private Long chunkSize = 5L;
-                        private Long chunkPosition = 0L;
-
-                        @Override
-                        public void onSubscribe(Subscription s) {
-                            this.subscription = s;
-                            subscription.request(chunkSize);
-                        }
-
-                        @Override
-                        public void onNext(Object t) {
-                            BiConsumer accumulator = (BiConsumer) collectStage.getCollector().accumulator();
-                            accumulator.accept(null, t);
-                            accumulator.andThen((o, o2) -> {
-                                incrementAndCheckChunkPosition();
-                            });
-                        }
-
-                        @Override
-                        public void onError(Throwable t) {
-                            throw new RuntimeException(t);
-                        }
-
-                        @Override
-                        public void onComplete() {
-                            completableFuture.complete(null);
-                        }
-
-                        private void incrementAndCheckChunkPosition() {
-                            chunkPosition++;
-                            if (chunkPosition >= chunkSize) {
-                                chunkPosition = 0L;
-                                subscription.request(chunkSize);
-                            }
-                        }
-                    };
-                }
-            };
-        }
-        throw new UnsupportedOperationException("Not implemented yet!!!");
+        MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
+        graph.getStages().stream().collect(multiStagesCollector);
+        return multiStagesCollector.getSubscriberWithCompletionStage();
     }
 
     @Override
@@ -119,7 +57,7 @@ public  Processor buildProcessor(Graph graph) throws UnsupportedStag
     public  CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException {
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
-        CompletionStage completionStage = (CompletionStage) multiStagesCollector.toCompletableStage();
+        CompletionStage completionStage = (CompletionStage) multiStagesCollector.getCompletableStage();
         return completionStage;
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
new file mode 100644
index 00000000000..e3d780fb43d
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+
+public class HelidonSubscriberWithCompletionStage implements SubscriberWithCompletionStage {
+
+    private final Processor connectingProcessor;
+    private Subscriber subscriber;
+    private CompletableFuture completableFuture = new CompletableFuture<>();
+    private Stage.Collect collectStage;
+    private LinkedList> processorList = new LinkedList<>();
+
+
+    /**
+     * Subscriber with preceding processors included, automatically makes all downstream subscriptions when its subscribe method is called.
+     *
+     * @param collectStage
+     * @param precedingProcessorList
+     */
+    public HelidonSubscriberWithCompletionStage(Stage.Collect collectStage, List> precedingProcessorList) {
+        this.collectStage = collectStage;
+        //preceding processors
+        precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
+        subscriber = (Subscriber) prepareSubscriber();
+        connectingProcessor = prepareConnectingProcessor();
+    }
+
+    @Override
+    public CompletionStage getCompletion() {
+        return completableFuture;
+    }
+
+    @Override
+    public Subscriber getSubscriber() {
+        return (Subscriber) connectingProcessor;
+    }
+
+    private Subscriber prepareSubscriber() {
+        return new Subscriber() {
+
+            private Subscription subscription;
+            private final AtomicBoolean closed = new AtomicBoolean(false);
+
+            @Override
+            public void onSubscribe(Subscription s) {
+                this.subscription = s;
+                subscription.request(1);
+            }
+
+            @Override
+            public void onNext(Object t) {
+                if (!closed.get()) {
+                    BiConsumer accumulator = (BiConsumer) collectStage.getCollector().accumulator();
+                    accumulator.accept(null, t);
+                    subscription.request(1);
+                }
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                throw new RuntimeException(t);
+            }
+
+            @Override
+            public void onComplete() {
+                closed.set(true);
+                completableFuture.complete(null);
+                subscription.cancel();
+            }
+        };
+    }
+
+    private Processor prepareConnectingProcessor() {
+        return new Processor() {
+            @Override
+            public void subscribe(Subscriber s) {
+                processorList.getFirst().subscribe(s);
+            }
+
+            @Override
+            public void onSubscribe(Subscription s) {
+                // This is a time for connecting all pre-processors and subscriber
+                Processor lastProcessor = null;
+                for (Iterator> it = processorList.iterator(); it.hasNext(); ) {
+                    Processor processor = it.next();
+                    if (lastProcessor != null) {
+                        lastProcessor.subscribe(processor);
+                    }
+                    lastProcessor = processor;
+                }
+                if (!processorList.isEmpty()) {
+                    processorList.getLast().subscribe(subscriber);
+                    // First preprocessor act as subscriber
+                    subscriber = processorList.getFirst();
+                }
+                //No processors just forward to subscriber
+                subscriber.onSubscribe(s);
+            }
+
+            @Override
+            public void onNext(Object o) {
+                subscriber.onNext(o);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                subscriber.onError(t);
+            }
+
+            @Override
+            public void onComplete() {
+                subscriber.onComplete();
+            }
+        };
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index 5c390352a37..d85ee6b2b0b 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -16,13 +16,20 @@
 
 package io.helidon.microprofile.reactive;
 
+import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.LimitProcessor;
 import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.MultiMappingProcessor;
+import io.helidon.common.reactive.PeekProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -42,14 +49,29 @@
 public class MultiStagesCollector implements Collector, CompletionStage> {
 
     private Multi multi = null;
-    private CompletableFuture completableFuture = null;
+    private List> processorList = new ArrayList<>();
+    private CompletionStage completionStage = null;
+    private HelidonSubscriberWithCompletionStage subscriberWithCompletionStage = null;
 
     @Override
     public Supplier> supplier() {
         return () -> multi != null ? multi : Multi.empty();
     }
 
+    private void subscribeUpStream() {
+        // If producer was supplied
+        if (multi != null) {
+            for (Flow.Processor p : processorList) {
+                multi.subscribe(p);
+                multi = (Multi) p;
+            }
+        } else {
+            throw new RuntimeException("No producer was supplied");
+        }
+    }
+
     public Publisher getPublisher() {
+        subscribeUpStream();
         return MultiRS.from(multi);
     }
 
@@ -74,43 +96,41 @@ public BiConsumer, Stage> accumulator() {
             } else if (stage instanceof Stage.Map) {
                 // Transform stream
                 Stage.Map mapStage = (Stage.Map) stage;
-                Function mapper = (Function) mapStage.getMapper();
-                multi = Multi.from(multi).map(mapper::apply);
+                Function mapper = (Function) mapStage.getMapper();
+                processorList.add(new MultiMappingProcessor<>(mapper::apply));
 
             } else if (stage instanceof Stage.Filter) {
                 //Filter stream
                 Stage.Filter stageFilter = (Stage.Filter) stage;
                 Predicate predicate = (Predicate) stageFilter.getPredicate();
-                multi = multi.filter(predicate);
+                processorList.add(new FilterProcessor(predicate));
 
             } else if (stage instanceof Stage.Peek) {
                 Stage.Peek peekStage = (Stage.Peek) stage;
-                Consumer peekConsumer = (Consumer) peekStage.getConsumer();
-                multi = multi.peek(peekConsumer::accept);
+                Consumer peekConsumer = (Consumer) peekStage.getConsumer();
+                processorList.add(new PeekProcessor(peekConsumer::accept));
+
+            } else if (stage instanceof Stage.Limit) {
+                Stage.Limit limitStage = (Stage.Limit) stage;
+                processorList.add(new LimitProcessor(limitStage.getLimit()));
 
             } else if (stage instanceof Stage.SubscriberStage) {
                 //Subscribe to stream
                 Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
                 Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
-                this.completableFuture = new CompletableFuture<>();
-                CompletionSubscriber completionSubscriber = CompletionSubscriber.of(subscriber, completableFuture);
+                this.completionStage = new CompletableFuture<>();
+                CompletionSubscriber completionSubscriber = CompletionSubscriber.of(subscriber, completionStage);
+                // If producer was supplied
+                subscribeUpStream();
                 multi.subscribe(HybridSubscriber.from(completionSubscriber));
 
             } else if (stage instanceof Stage.Collect) {
-                //Collect stream
-                Stage.Collect stageFilter = (Stage.Collect) stage;
-                Collector collector = (Collector) stageFilter.getCollector();
-                multi.collect(new io.helidon.common.reactive.Collector() {
-                    @Override
-                    public void collect(T item) {
-                        collector.finisher().apply(item);
-                    }
-
-                    @Override
-                    public T value() {
-                        return null;
-                    }
-                });
+                // Foreach
+                Stage.Collect collectStage = (Stage.Collect) stage;
+                this.subscriberWithCompletionStage = new HelidonSubscriberWithCompletionStage<>(collectStage, processorList);
+                // If producer was supplied
+                //getPublisher().subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
+
             } else {
                 throw new UnsupportedStageException(stage);
             }
@@ -124,7 +144,7 @@ public BinaryOperator> combiner() {
 
     @Override
     public Function, CompletionStage> finisher() {
-        return t -> toCompletableStage();
+        return t -> getCompletableStage();
     }
 
     @Override
@@ -132,7 +152,11 @@ public Set characteristics() {
         return new HashSet<>(Collections.singletonList(Characteristics.IDENTITY_FINISH));
     }
 
-    public CompletionStage toCompletableStage() {
-        return completableFuture;
+    public  SubscriberWithCompletionStage getSubscriberWithCompletionStage() {
+        return (SubscriberWithCompletionStage) subscriberWithCompletionStage;
+    }
+
+    public  CompletionStage getCompletableStage() {
+        return (CompletionStage) (completionStage != null ? completionStage : subscriberWithCompletionStage.getCompletion());
     }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
new file mode 100644
index 00000000000..6c942d6952f
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive.hybrid;
+
+import io.helidon.common.reactive.Flow;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.security.InvalidParameterException;
+
+public class HybridProcessor implements Flow.Processor, Processor {
+    private Processor reactiveProcessor;
+    private Flow.Processor flowProcessor;
+
+    private HybridProcessor(Processor processor) {
+        this.reactiveProcessor = processor;
+    }
+
+    private HybridProcessor(Flow.Processor processor) {
+        this.flowProcessor = processor;
+    }
+
+    public static  HybridProcessor from(Flow.Processor processor) {
+        return new HybridProcessor(processor);
+    }
+
+    public static  HybridProcessor from(Processor processor) {
+        return new HybridProcessor(processor);
+    }
+
+    @Override
+    public void subscribe(Flow.Subscriber subscriber) {
+        this.subscribe((Subscriber) HybridSubscriber.from(subscriber));
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        if (reactiveProcessor != null) {
+            reactiveProcessor.subscribe(s);
+        } else if (flowProcessor != null) {
+            flowProcessor.subscribe(HybridSubscriber.from(s));
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        this.onSubscribe(subscription);
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        if (reactiveProcessor != null) {
+            reactiveProcessor.onSubscribe(s);
+        } else if (flowProcessor != null) {
+            flowProcessor.onSubscribe(HybridSubscription.from(s));
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
+    }
+
+    @Override
+    public void onNext(T item) {
+        if (reactiveProcessor != null) {
+            reactiveProcessor.onNext(item);
+        } else if (flowProcessor != null) {
+            flowProcessor.onNext(item);
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        if (reactiveProcessor != null) {
+            reactiveProcessor.onError(throwable);
+        } else if (flowProcessor != null) {
+            flowProcessor.onError(throwable);
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
+    }
+
+    @Override
+    public void onComplete() {
+        if (reactiveProcessor != null) {
+            reactiveProcessor.onComplete();
+        } else if (flowProcessor != null) {
+            flowProcessor.onComplete();
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
+    }
+
+    @Override
+    public String toString() {
+        return reactiveProcessor != null ? reactiveProcessor.toString() : String.valueOf(flowProcessor);
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 7f8d071ed05..2d25d937b39 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -46,12 +46,24 @@ public static  HybridSubscriber from(Subscriber subscriber) {
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
-        reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        if (flowSubscriber != null) {
+            flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        } else if (reactiveSubscriber != null) {
+            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        } else {
+            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
+        }
     }
 
     @Override
     public void onSubscribe(Subscription subscription) {
-        flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        if (flowSubscriber != null) {
+            flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        } else if (reactiveSubscriber != null) {
+            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
+        } else {
+            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
+        }
     }
 
     @Override
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
index 786e72f3241..94ce51a09f5 100644
--- a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
@@ -20,30 +20,40 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 
 public class ConsumableSubscriber implements Subscriber {
 
     private Consumer onNext;
+    private AtomicLong requestCount = new AtomicLong(1000);
     private Subscription subscription;
-    private Long chunkSize = 20L;
-    private Long chunkPosition = 0L;
+    private final AtomicBoolean closed = new AtomicBoolean(false);
 
     public ConsumableSubscriber(Consumer onNext) {
         this.onNext = onNext;
     }
+    public ConsumableSubscriber(Consumer onNext, long requestCount) {
+        this.onNext = onNext;
+        this.requestCount.set(requestCount);
+    }
 
     @Override
     public void onSubscribe(Subscription s) {
         this.subscription = s;
         //First chunk request
-        subscription.request(chunkSize);
+        subscription.request(requestCount.get());
     }
 
     @Override
     public void onNext(T o) {
-        onNext.accept(o);
-        incrementAndCheckChunkPosition();
+        if (!closed.get()) {
+            onNext.accept(o);
+            if(0 == requestCount.decrementAndGet()){
+                subscription.cancel();
+            }
+        }
     }
 
     @Override
@@ -53,13 +63,7 @@ public void onError(Throwable t) {
 
     @Override
     public void onComplete() {
-    }
-
-    private void incrementAndCheckChunkPosition() {
-        chunkPosition++;
-        if (chunkPosition >= chunkSize) {
-            chunkPosition = 0L;
-            subscription.request(chunkSize);
-        }
+        closed.set(true);
+        subscription.cancel();
     }
 }
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 9711a75f59a..889d1397fbd 100644
--- a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microrofile.reactive;
 
+import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.junit.jupiter.api.Test;
 
@@ -55,9 +56,10 @@ void fixedItemsWithFilter() {
     void publisherWithMapAndPeekAndFilter() {
         AtomicInteger peekSum = new AtomicInteger();
         AtomicInteger sum = new AtomicInteger();
-        IntSequencePublisher intSequencePublisher = new IntSequencePublisher(10);
+        IntSequencePublisher intSequencePublisher = new IntSequencePublisher();
 
         ReactiveStreams.fromPublisher(intSequencePublisher)
+                .limit(10)
                 .filter(x -> (x % 2) == 0)
                 .peek(peekSum::addAndGet)
                 .map(String::valueOf)
@@ -73,7 +75,7 @@ void publisherWithMapAndPeekAndFilter() {
     @Test
     void fromTo() throws ExecutionException, InterruptedException, TimeoutException {
         AtomicInteger sum = new AtomicInteger();
-        IntSequencePublisher publisher = new IntSequencePublisher(10);
+        IntSequencePublisher publisher = new IntSequencePublisher();
         StringBuilder beforeFilter = new StringBuilder();
         StringBuilder afterFilter = new StringBuilder();
         ReactiveStreams
@@ -85,12 +87,39 @@ void fromTo() throws ExecutionException, InterruptedException, TimeoutException
                 .map(Integer::parseInt)
                 .filter(i -> i <= 5)
                 .peek(afterFilter::append)
-                .to(ReactiveStreams.fromSubscriber(new ConsumableSubscriber<>(sum::addAndGet)))
-                .run()
-                .toCompletableFuture()
-                .get(1, TimeUnit.SECONDS);
+                .to(ReactiveStreams.fromSubscriber(new ConsumableSubscriber<>(sum::addAndGet, 10)))
+                .run();
         assertEquals("1-2-3-4-5-6-7-8-9-10-", beforeFilter.toString());
         assertEquals("12345", afterFilter.toString());
         assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
     }
+
+    @Test
+    void limit() {
+        AtomicInteger sum = new AtomicInteger();
+        IntSequencePublisher publisher = new IntSequencePublisher();
+        ConsumableSubscriber subscriber = new ConsumableSubscriber<>(sum::addAndGet);
+        ReactiveStreams
+                .fromPublisher(publisher)
+                //TODO: peak clashes with limit, probably because of onComplete is not called in limit processor
+//                .peek(System.out::println)
+                .limit(5)
+//                .peek(System.out::println)
+                .buildRs()
+                .subscribe(subscriber);
+        assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
+    }
+
+    @Test
+    void subscriberCreation() throws ExecutionException, InterruptedException {
+        AtomicInteger sum = new AtomicInteger();
+        IntSequencePublisher publisher = new IntSequencePublisher();
+        CompletionSubscriber subscriber = ReactiveStreams.builder()
+                .limit(5)
+                .peek(System.out::println)
+                .forEach(sum::addAndGet)
+                .build();
+        publisher.subscribe(subscriber);
+        assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
+    }
 }
\ No newline at end of file
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
index 6c5ce8fffff..a2bf04a6454 100644
--- a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
@@ -29,10 +29,8 @@ public class IntSequencePublisher implements Publisher, Subscription {
     private AtomicBoolean closed = new AtomicBoolean(false);
     private AtomicInteger sequence = new AtomicInteger(0);
     private Subscriber subscriber;
-    private int count;
 
-    public IntSequencePublisher(int count) {
-        this.count = count;
+    public IntSequencePublisher() {
     }
 
     @Override
@@ -43,18 +41,15 @@ public void subscribe(Subscriber s) {
 
     @Override
     public void request(long n) {
-        for (long i = 0; i < n
-                && !closed.get()
-                && sequence.get() < count; n++) {
+        for (long i = 0; i <= n
+                && !closed.get(); i++) {
             subscriber.onNext(sequence.incrementAndGet());
-            if(sequence.get() >= count){
-                subscriber.onComplete();
-            }
         }
     }
 
     @Override
     public void cancel() {
         closed.set(true);
+        subscriber.onComplete();
     }
 }

From 71b70071ccf534490eda27e5c0d7b736e88a3053 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 16 Nov 2019 19:42:50 +0100
Subject: [PATCH 14/66] Passing 12/14 tck tests

Signed-off-by: Daniel Kec 
---
 .../microprofile/messaging/reactive/InternalPublisher.java       | 1 -
 1 file changed, 1 deletion(-)

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
index 10a987e70ba..241e76d9153 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
@@ -59,7 +59,6 @@ public void request(long n) {
                     subscriber.onNext(result);
                 }
             }
-            subscriber.onComplete();
         } catch (IllegalAccessException | InvocationTargetException | InterruptedException | ExecutionException e) {
             subscriber.onError(e);
         }

From 07e6bd45a208472de76437945565b4c4a7f7c25b Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sun, 17 Nov 2019 23:03:53 +0100
Subject: [PATCH 15/66] Passing processor shape tests with Multi, not with
 small-rye

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  4 +-
 .../microprofile/messaging/MessageUtils.java  | 51 +++++++++++++
 .../messaging/channel/ProcessorMethod.java    |  7 +-
 .../messaging/reactive/ProxyProcessor.java    | 61 ++++++++++++++--
 .../messaging/reactive/UnwrapProcessor.java   | 36 +---------
 .../inner/AbstractShapeTestBean.java          |  1 +
 .../messaging/inner/InnerChannelTest.java     |  6 ++
 .../messaging/inner/ProcessorBean.java        | 53 ++++++++++++++
 .../messaging/inner/ProcessorBuilderBean.java | 50 +++++++++++++
 .../PublisherBuilderTransformerV1Bean.java    | 52 ++++++++++++++
 .../PublisherBuilderTransformerV2Bean.java    | 49 +++++++++++++
 .../inner/PublisherFromPublisherV1Bean.java   | 53 ++++++++++++++
 .../inner/PublisherFromPublisherV2Bean.java   | 50 +++++++++++++
 .../reactive/UnwrapProcessorTest.java         |  5 +-
 .../reactive/FlatMapProcessor.java            | 67 +++++++++++++++++
 .../reactive/HelidonCumulativeProcessor.java  | 72 +++++++++++++++++++
 .../reactive/HelidonReactiveStreamEngine.java |  4 +-
 .../reactive/MultiStagesCollector.java        | 15 +++-
 .../reactive/hybrid/HybridSubscriber.java     |  3 +
 .../microrofile/reactive/EngineTest.java      | 53 ++++++++++++--
 20 files changed, 641 insertions(+), 51 deletions(-)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBuilderBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
 create mode 100644 microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 79b87d424ed..4b1a4433568 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -28,7 +28,7 @@
  * @param  subscribed type (input)
  * @param  published type (output)
  */
-abstract class BaseProcessor implements Processor, Subscription {
+public abstract class BaseProcessor implements Processor, Subscription {
 
     private Subscription subscription;
     private final SingleSubscriberHolder subscriber;
@@ -38,7 +38,7 @@ abstract class BaseProcessor implements Processor, Subscription {
     private volatile boolean done;
     private Throwable error;
 
-    BaseProcessor() {
+    public BaseProcessor() {
         requested = new RequestedCounter();
         ready = new AtomicBoolean();
         subscribed = new AtomicBoolean();
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
index dd4509ae06f..e899b5b0ac2 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -18,6 +18,17 @@
 package io.helidon.microprofile.messaging;
 
 import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.security.InvalidParameterException;
 
 public class MessageUtils {
     public static Object unwrap(Object value, Class type) {
@@ -39,4 +50,44 @@ public static Object unwrap(Object value, Boolean isMessageType) {
             }
         }
     }
+
+    public static Object unwrap(Object o, Method method) {
+        return unwrap(o, isTypeMessage(method));
+    }
+
+    public static boolean isTypeMessage(Method method) {
+        Type returnType = method.getGenericReturnType();
+        ParameterizedType parameterizedType = (ParameterizedType) returnType;
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+
+        if (SubscriberBuilder.class.equals(method.getReturnType())) {
+            if (actualTypeArguments.length != 2) {
+                throw new DeploymentException("Invalid method return type " + method);
+            }
+            return isMessageType(actualTypeArguments[0]);
+
+        } else if (Subscriber.class.equals(method.getReturnType())) {
+            if (actualTypeArguments.length != 1) {
+                throw new DeploymentException("Invalid method return type " + method);
+            }
+            return isMessageType(actualTypeArguments[0]);
+
+        } else if (Processor.class.equals(method.getReturnType())) {
+            return isMessageType(actualTypeArguments[0]);
+
+        } else if (ProcessorBuilder.class.equals(method.getReturnType())) {
+            return isMessageType(actualTypeArguments[0]);
+
+        }
+        throw new InvalidParameterException("Unsupported method for unwrapping " + method);
+    }
+
+    private static boolean isMessageType(Type type) {
+        if (type instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            return Message.class.equals(parameterizedType.getRawType());
+        }
+        return false;
+    }
+
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index d0535a51a5a..4dc48aeb44a 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -102,7 +102,12 @@ public void setOutgoingChannel(UniversalChannel outgoingChannel) {
 
     private void resolveSignatureType() {
         Class returnType = this.method.getReturnType();
-        Class parameterType = this.method.getParameterTypes()[0];
+            Class parameterType = Void.TYPE;
+        if (this.method.getParameterTypes().length == 1) {
+            parameterType = this.method.getParameterTypes()[0];
+        } else if (this.method.getParameterTypes().length > 1) {
+            throw new DeploymentException("Bad processor method signature " + method);
+        }
         if (Void.TYPE.equals(parameterType)) {
             if (Processor.class.equals(returnType)) {
                 this.type = Type.PROCESSOR_VOID_2_PROCESSOR;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
index 262febc412c..03e55521de0 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
@@ -17,8 +17,10 @@
 
 package io.helidon.microprofile.messaging.reactive;
 
+import io.helidon.microprofile.messaging.MessageUtils;
 import io.helidon.microprofile.messaging.channel.AbstractChannel;
 import io.helidon.microprofile.messaging.channel.ProcessorMethod;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.jboss.weld.exceptions.DeploymentException;
@@ -44,8 +46,10 @@ public class ProxyProcessor implements Processor {
     private final ProcessorMethod processorMethod;
     private final Publisher publisher;
     private Subscriber subscriber;
+    private Processor processor;
     private boolean subscribed = false;
 
+    @SuppressWarnings("unchecked")
     public ProxyProcessor(ProcessorMethod processorMethod) {
         this.processorMethod = processorMethod;
         try {
@@ -54,6 +58,24 @@ public ProxyProcessor(ProcessorMethod processorMethod) {
                 publisher = ((PublisherBuilder) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance(), paramPublisherBuilder)).buildRs();
+
+            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_PUBLISHER_2_PUBLISHER) {
+                publisher = ((Publisher) processorMethod
+                        .getMethod()
+                        .invoke(processorMethod.getBeanInstance(), this));
+
+            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER) {
+                processor = ((ProcessorBuilder) processorMethod
+                        .getMethod()
+                        .invoke(processorMethod.getBeanInstance())).buildRs();
+                publisher = processor;
+
+            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_VOID_2_PROCESSOR) {
+                processor = ((Processor) processorMethod
+                        .getMethod()
+                        .invoke(processorMethod.getBeanInstance()));
+                publisher = processor;
+
             } else {
                 throw new UnsupportedOperationException("Not implemented yet!");
             }
@@ -65,33 +87,58 @@ public ProxyProcessor(ProcessorMethod processorMethod) {
 
     @Override
     public void subscribe(Subscriber s) {
-        if (publisher == null) {
+        if (processor != null) {
+            // Backed by real  processor
+            processor.subscribe(s);
+        } else if (publisher == null) {
+            //Differences between small-rye and Multi impl
             subscriber = s;
-        } else if(!subscribed){
+        } else if (!subscribed) {
             subscribed = true;
             publisher.subscribe(s);
-        }else{
+        } else {
             throw new DeploymentException("Already subscribed");
         }
     }
 
     @Override
     public void onSubscribe(Subscription s) {
-        subscriber.onSubscribe(s);
+        if (processor != null) {
+            // Backed by real  processor
+            processor.onSubscribe(s);
+        } else {
+            subscriber.onSubscribe(s);
+        }
     }
 
     @Override
     public void onNext(Object o) {
-        subscriber.onNext(o);
+        //TODO: Cleanup by assigning processor to publisher and subscriber instead of all those ifs
+        if (processor != null) {
+            // Backed by real  processor
+            processor.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
+        } else {
+            subscriber.onNext(o);
+        }
     }
 
     @Override
     public void onError(Throwable t) {
-        subscriber.onError(t);
+        if (processor != null) {
+            // Backed by real  processor
+            processor.onError(t);
+        } else {
+            subscriber.onError(t);
+        }
     }
 
     @Override
     public void onComplete() {
-        subscriber.onComplete();
+        if (processor != null) {
+            // Backed by real  processor
+            processor.onComplete();
+        } else {
+            subscriber.onComplete();
+        }
     }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
index ebaa740ec56..91156ce646c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
@@ -18,23 +18,18 @@
 package io.helidon.microprofile.messaging.reactive;
 
 import io.helidon.microprofile.messaging.MessageUtils;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import javax.enterprise.inject.spi.DeploymentException;
-
 import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.security.InvalidParameterException;
 
 /**
  * Unwrap Message payload if incoming method Publisher or Publisher builder
  * has generic return type different than Message
  */
+//TODO: Remove and replace with MessageUtils static call
+@Deprecated
 public class UnwrapProcessor implements Processor {
 
     private Method method;
@@ -51,34 +46,9 @@ public static UnwrapProcessor of(Method method, Subscriber subscriber) {
     }
 
     Object unwrap(Object o) {
-        return MessageUtils.unwrap(o, isTypeMessage(method));
-    }
-
-    static boolean isTypeMessage(Method method) {
-        Type returnType = method.getGenericReturnType();
-        ParameterizedType parameterizedType = (ParameterizedType) returnType;
-        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
-        if (SubscriberBuilder.class.equals(method.getReturnType())) {
-            if (actualTypeArguments.length != 2) {
-                throw new DeploymentException("Invalid method return type " + method);
-            }
-            return isMessageType(actualTypeArguments[0]);
-        } else if (Subscriber.class.equals(method.getReturnType())) {
-            if (actualTypeArguments.length != 1) {
-                throw new DeploymentException("Invalid method return type " + method);
-            }
-            return isMessageType(actualTypeArguments[0]);
-        }
-        throw new InvalidParameterException("Only methods with Subscriber or Subscriber builder should be unwrapped by processor");
+        return MessageUtils.unwrap(o, method);
     }
 
-    private static boolean isMessageType(Type type) {
-        if (type instanceof ParameterizedType) {
-            ParameterizedType parameterizedType = (ParameterizedType) type;
-            return Message.class.equals(parameterizedType.getRawType());
-        }
-        return false;
-    }
 
     @Override
     public void subscribe(Subscriber subscriber) {
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
index 5aa7952b4d2..cfeccac854a 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/AbstractShapeTestBean.java
@@ -27,6 +27,7 @@
 public abstract class AbstractShapeTestBean implements CountableTestBean {
 
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+    public static Set TEST_INT_DATA = new HashSet<>(Arrays.asList(1, 2, 3));
 
     public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index c329a52e538..2de74ed56cb 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -40,6 +40,12 @@ public void setUp() {
     static Stream testCaseSource() {
         return Stream.of(
                 //Positive tests
+                CdiTestCase.from(PublisherBuilderTransformerV2Bean.class),
+                CdiTestCase.from(PublisherBuilderTransformerV1Bean.class),
+                CdiTestCase.from(PublisherFromPublisherV2Bean.class),
+                CdiTestCase.from(PublisherFromPublisherV1Bean.class),
+                CdiTestCase.from(ProcessorBean.class),
+                CdiTestCase.from(ProcessorBuilderBean.class),
                 CdiTestCase.from(PullForEachBean.class),
                 CdiTestCase.from(CompletionStageV1Bean.class),
                 CdiTestCase.from(PublisherPayloadV6Bean.class),
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBean.java
new file mode 100644
index 00000000000..8ccb2975856
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBean.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ProcessorBean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-processor-message")
+    public PublisherBuilder streamForProcessorOfMessages() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-processor-message")
+    @Outgoing("processor-message")
+    public Processor, Message> processorOfMessages() {
+        return ReactiveStreams.>builder()
+                .map(Message::getPayload)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("processor-message")
+    public void getMessgesFromProcessorOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBuilderBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBuilderBean.java
new file mode 100644
index 00000000000..f421fcf4529
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ProcessorBuilderBean.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class ProcessorBuilderBean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-processor-builder-payload")
+    public PublisherBuilder streamForProcessorBuilderOfPayloads() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-processor-builder-payload")
+    @Outgoing("processor-builder-payload")
+    public ProcessorBuilder processorBuilderOfPayloads() {
+        return ReactiveStreams.builder()
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i));
+    }
+
+    @Incoming("processor-builder-payload")
+    public void getMessagesFromProcessorBuilderOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java
new file mode 100644
index 00000000000..3ba4d2f7de7
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherBuilderTransformerV1Bean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-publisher-builder-message")
+    public PublisherBuilder streamForProcessorBuilderOfMessages() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-publisher-builder-message")
+    @Outgoing("publisher-builder-message")
+    public PublisherBuilder> processorBuilderOfMessages(PublisherBuilder> stream) {
+        return stream
+                .map(Message::getPayload)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .map(Message::of);
+    }
+
+    @Incoming("publisher-builder-message")
+    public void getMessgesFromProcessorBuilderOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java
new file mode 100644
index 00000000000..16c3354b099
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherBuilderTransformerV2Bean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-publisher-builder-payload")
+    public PublisherBuilder streamForProcessorBuilderOfPayloads() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-publisher-builder-payload")
+    @Outgoing("publisher-builder-payload")
+    public PublisherBuilder processorBuilderOfPayloads(PublisherBuilder stream) {
+        return stream
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i));
+    }
+
+    @Incoming("publisher-builder-payload")
+    public void getMessgesFromProcessorBuilderOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java
new file mode 100644
index 00000000000..1ab07e9e590
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherFromPublisherV1Bean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-publisher-message")
+    public PublisherBuilder streamForProcessorOfMessages() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-publisher-message")
+    @Outgoing("publisher-message")
+    public Publisher> processorOfMessages(Publisher> stream) {
+        return ReactiveStreams.fromPublisher(stream)
+                .map(Message::getPayload)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("publisher-message")
+    public void getMessgesFromProcessorOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java
new file mode 100644
index 00000000000..5184aeed4d8
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class PublisherFromPublisherV2Bean extends AbstractShapeTestBean {
+
+    @Outgoing("publisher-for-publisher-payload")
+    public PublisherBuilder streamForProcessorOfPayloads() {
+        return ReactiveStreams.of(TEST_INT_DATA.toArray(new Integer[0]));
+    }
+
+    @Incoming("publisher-for-publisher-payload")
+    @Outgoing("publisher-payload")
+    public Publisher processorOfPayloads(Publisher stream) {
+        return ReactiveStreams.fromPublisher(stream)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .buildRs();
+    }
+
+    @Incoming("publisher-payload")
+    public void getMessgesFromProcessorOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
index ec8f98ac12d..34dce21b0a9 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.messaging.reactive;
 
+import io.helidon.microprofile.messaging.MessageUtils;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
@@ -60,10 +61,10 @@ void innerChannelBeanTest(Method method) {
         unwrapProcessor.setMethod(method);
         Object unwrappedValue = unwrapProcessor.unwrap(Message.of("test"));
         if (method.getName().endsWith("Message")) {
-            assertTrue(UnwrapProcessor.isTypeMessage(method));
+            assertTrue(MessageUtils.isTypeMessage(method));
             assertTrue(unwrappedValue instanceof Message);
         } else {
-            assertFalse(UnwrapProcessor.isTypeMessage(method));
+            assertFalse(MessageUtils.isTypeMessage(method));
             assertFalse(unwrappedValue instanceof Message);
         }
     }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
new file mode 100644
index 00000000000..c7582a2099f
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.BaseProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
+import org.reactivestreams.Publisher;
+
+import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
+
+public class FlatMapProcessor extends BaseProcessor implements Multi {
+
+    private final Function mapper;
+    private Flow.Subscriber subscriber;
+
+    public FlatMapProcessor(Function mapper) {
+        this.mapper = (Function) mapper;
+    }
+
+    @Override
+    protected void hookOnNext(Object item) {
+        Graph graph = mapper.apply(item);
+        HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
+        Publisher publisher = streamEngine.buildPublisher(graph);
+        try {
+            ReactiveStreams
+                    .fromPublisher(publisher)
+                    .forEach(subItem -> submit(subItem))
+                    .run().toCompletableFuture().get();
+        } catch (InterruptedException | ExecutionException e) {
+            onError(e);
+        }
+    }
+
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    public String toString() {
+        return "FlatMapProcessor{" +
+                "mapper=" + mapper +
+                ", subscriber=" + subscriber +
+                '}';
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
new file mode 100644
index 00000000000..c8d84b00062
--- /dev/null
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class HelidonCumulativeProcessor implements Processor {
+    private LinkedList> processorList = new LinkedList<>();
+    private Processor subscriber;
+
+    public HelidonCumulativeProcessor(List> precedingProcessorList) {
+        //preceding processors
+        precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
+    }
+
+    @Override
+    public void subscribe(Subscriber s) {
+        processorList.getLast().subscribe(s);
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        // This is the time for connecting all processors
+        Processor lastProcessor = null;
+        for (Iterator> it = processorList.iterator(); it.hasNext(); ) {
+            Processor processor = it.next();
+            if (lastProcessor != null) {
+                lastProcessor.subscribe(processor);
+            }
+            lastProcessor = processor;
+        }
+        processorList.getFirst().onSubscribe(subscription);
+    }
+
+    @Override
+    public void onNext(Object o) {
+        processorList.getFirst().onNext(o);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        processorList.getFirst().onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        processorList.getFirst().onComplete();
+    }
+}
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 3906fa5c461..34cd26edd6d 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -50,7 +50,9 @@ public  SubscriberWithCompletionStage buildSubscriber(Graph graph) t
 
     @Override
     public  Processor buildProcessor(Graph graph) throws UnsupportedStageException {
-        throw new UnsupportedOperationException("Not implemented yet!!!");
+        MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
+        graph.getStages().stream().collect(multiStagesCollector);
+        return multiStagesCollector.getProcessor();
     }
 
     @Override
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index d85ee6b2b0b..2f52bce705e 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -23,9 +23,11 @@
 import io.helidon.common.reactive.MultiMappingProcessor;
 import io.helidon.common.reactive.PeekProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
+import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -114,6 +116,11 @@ public BiConsumer, Stage> accumulator() {
                 Stage.Limit limitStage = (Stage.Limit) stage;
                 processorList.add(new LimitProcessor(limitStage.getLimit()));
 
+            } else if (stage instanceof Stage.FlatMap) {
+                Stage.FlatMap flatMapStage = (Stage.FlatMap) stage;
+                Function mapper = flatMapStage.getMapper();
+                processorList.add(new FlatMapProcessor(mapper));
+
             } else if (stage instanceof Stage.SubscriberStage) {
                 //Subscribe to stream
                 Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
@@ -129,7 +136,9 @@ public BiConsumer, Stage> accumulator() {
                 Stage.Collect collectStage = (Stage.Collect) stage;
                 this.subscriberWithCompletionStage = new HelidonSubscriberWithCompletionStage<>(collectStage, processorList);
                 // If producer was supplied
-                //getPublisher().subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
+                if(multi != null){
+                    multi.subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
+                }
 
             } else {
                 throw new UnsupportedStageException(stage);
@@ -159,4 +168,8 @@ public  SubscriberWithCompletionStage getSubscriberWithCompletionSta
     public  CompletionStage getCompletableStage() {
         return (CompletionStage) (completionStage != null ? completionStage : subscriberWithCompletionStage.getCompletion());
     }
+
+    public  Processor getProcessor() {
+        return (Processor) new HelidonCumulativeProcessor(processorList);
+    }
 }
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 2d25d937b39..5e5187fb9e2 100644
--- a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -22,6 +22,7 @@
 import org.reactivestreams.Subscription;
 
 import java.security.InvalidParameterException;
+import java.util.Objects;
 
 public class HybridSubscriber implements Flow.Subscriber, Subscriber {
 
@@ -37,10 +38,12 @@ private HybridSubscriber(Subscriber subscriber) {
     }
 
     public static  HybridSubscriber from(Flow.Subscriber subscriber) {
+        Objects.requireNonNull(subscriber);
         return new HybridSubscriber(subscriber);
     }
 
     public static  HybridSubscriber from(Subscriber subscriber) {
+        Objects.requireNonNull(subscriber);
         return new HybridSubscriber(subscriber);
     }
 
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 889d1397fbd..2aabd5a35f3 100644
--- a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -17,12 +17,14 @@
 
 package io.helidon.microrofile.reactive;
 
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
 
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -101,10 +103,9 @@ void limit() {
         ConsumableSubscriber subscriber = new ConsumableSubscriber<>(sum::addAndGet);
         ReactiveStreams
                 .fromPublisher(publisher)
-                //TODO: peak clashes with limit, probably because of onComplete is not called in limit processor
-//                .peek(System.out::println)
+                .peek(System.out::println)
                 .limit(5)
-//                .peek(System.out::println)
+                .peek(System.out::println)
                 .buildRs()
                 .subscribe(subscriber);
         assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
@@ -122,4 +123,48 @@ void subscriberCreation() throws ExecutionException, InterruptedException {
         publisher.subscribe(subscriber);
         assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
     }
+
+    @Test
+    void processorBuilder() {
+        StringBuffer stringBuffer = new StringBuffer();
+
+        Publisher publisherBuilder =
+                ReactiveStreams
+                        .of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+                        .buildRs();
+
+        Processor processor = ReactiveStreams.builder()
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .buildRs();
+
+        ConsumableSubscriber subscriber = new ConsumableSubscriber<>(stringBuffer::append);
+
+        publisherBuilder.subscribe(processor);
+        processor.subscribe(HybridSubscriber.from(subscriber));
+
+        assertEquals("1122334455667788991010", stringBuffer.toString());
+    }
+
+    @Test
+    void ofForEach() throws ExecutionException, InterruptedException {
+        AtomicInteger sum = new AtomicInteger();
+        ReactiveStreams
+                .of(3, 4)
+                .forEach(sum::addAndGet)
+                .run();
+                //.toCompletableFuture().get();
+        assertEquals(3 + 4, sum.get());
+    }
+    @Test
+    void publisherToForEach() {
+        AtomicInteger sum = new AtomicInteger();
+        Publisher publisher = ReactiveStreams.of(3, 4).buildRs();
+        ReactiveStreams
+                .fromPublisher(publisher)
+                .forEach(sum::addAndGet)
+                .run();
+        assertEquals(3 + 4, sum.get());
+    }
 }
\ No newline at end of file

From df643ea012e6284ab64b2b166210d048c9ca5b63 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 18 Nov 2019 13:32:46 +0100
Subject: [PATCH 16/66] Passing all MicroProfile Reactive Messaging tck tests

Signed-off-by: Daniel Kec 
---
 .../microprofile/messaging/MessageUtils.java  | 52 +++++++++--
 .../messaging/reactive/InternalProcessor.java | 31 ++++++-
 .../reactive/InternalSubscriber.java          |  1 +
 .../messaging/reactive/ProxyProcessor.java    | 25 +++---
 .../messaging/reactive/UnwrapProcessor.java   |  9 +-
 .../messaging/MessageUtilsTest.java           | 88 +++++++++++++++++++
 ...ean.java => ByRequestProcessorV1Bean.java} |  2 +-
 .../inner/ByRequestProcessorV2Bean.java       | 55 ++++++++++++
 .../inner/ByRequestProcessorV3Bean.java       | 56 ++++++++++++
 .../inner/ByRequestProcessorV4Bean.java       | 59 +++++++++++++
 .../inner/ByRequestProcessorV5Bean.java       | 58 ++++++++++++
 .../messaging/inner/InnerChannelTest.java     | 61 +++++++------
 ... => MultipleTypeProcessorChainV1Bean.java} |  2 +-
 .../MultipleTypeProcessorChainV2Bean.java     | 78 ++++++++++++++++
 .../inner/PublisherProcessorV1Bean.java       | 63 +++++++++++++
 .../inner/PublisherProcessorV2Bean.java       | 60 +++++++++++++
 .../inner/PublisherProcessorV3Bean.java       | 61 +++++++++++++
 .../inner/PublisherProcessorV4Bean.java       | 58 ++++++++++++
 .../reactive/UnwrapProcessorTest.java         |  3 +-
 microprofile/tests/tck/pom.xml                |  1 +
 20 files changed, 769 insertions(+), 54 deletions(-)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{PrimitiveProcessorBean.java => ByRequestProcessorV1Bean.java} (97%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV3Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV4Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV5Bean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{MultipleTypeProcessorChainBean.java => MultipleTypeProcessorChainV1Bean.java} (96%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
index e899b5b0ac2..44605790797 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
@@ -19,8 +19,10 @@
 
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
 import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
 import javax.enterprise.inject.spi.DeploymentException;
@@ -29,14 +31,14 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.security.InvalidParameterException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 
 public class MessageUtils {
-    public static Object unwrap(Object value, Class type) {
-        return unwrap(value, type.equals(Message.class));
-    }
 
-    public static Object unwrap(Object value, Boolean isMessageType) {
-        if (isMessageType) {
+    public static Object unwrap(Object value, Class type) throws ExecutionException, InterruptedException {
+        //TODO: Stream-line case by case
+        if (type.equals(Message.class)) {
             if (value instanceof Message) {
                 return value;
             } else {
@@ -44,15 +46,30 @@ public static Object unwrap(Object value, Boolean isMessageType) {
             }
         } else {
             if (value instanceof Message) {
-                return ((Message) value).getPayload();
+                Object payload = ((Message) value).getPayload();
+                return unwrapCompletableFuture(payload, type);
+            } else if (value instanceof CompletableFuture) {
+                //Recursion for Message>>
+                return unwrap(((CompletableFuture) value).get(), type);
             } else {
                 return value;
             }
         }
     }
 
-    public static Object unwrap(Object o, Method method) {
-        return unwrap(o, isTypeMessage(method));
+    public static Object unwrapCompletableFuture(Object o, Class expectedType) throws ExecutionException, InterruptedException {
+        if (CompletableFuture.class.isInstance(o) && !CompletableFuture.class.isAssignableFrom(expectedType)) {
+            //Recursion for Message>>
+            return unwrap(((CompletableFuture) o).get(), expectedType);
+        }
+        return o;
+    }
+
+    public static Object unwrap(Object o, Method method) throws ExecutionException, InterruptedException {
+        if (isTypeMessage(method)) {
+            return unwrap(o, Message.class);
+        }
+        return unwrap(o, getFirstGenericType(method));
     }
 
     public static boolean isTypeMessage(Method method) {
@@ -60,6 +77,7 @@ public static boolean isTypeMessage(Method method) {
         ParameterizedType parameterizedType = (ParameterizedType) returnType;
         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
 
+        //TODO: Use AbstractChannel.Type enum instead
         if (SubscriberBuilder.class.equals(method.getReturnType())) {
             if (actualTypeArguments.length != 2) {
                 throw new DeploymentException("Invalid method return type " + method);
@@ -78,6 +96,12 @@ public static boolean isTypeMessage(Method method) {
         } else if (ProcessorBuilder.class.equals(method.getReturnType())) {
             return isMessageType(actualTypeArguments[0]);
 
+        } else if (PublisherBuilder.class.equals(method.getReturnType())) {
+            return isMessageType(actualTypeArguments[0]);
+
+        } else if (Publisher.class.equals(method.getReturnType())) {
+            return isMessageType(actualTypeArguments[0]);
+
         }
         throw new InvalidParameterException("Unsupported method for unwrapping " + method);
     }
@@ -90,4 +114,16 @@ private static boolean isMessageType(Type type) {
         return false;
     }
 
+    private static Class getFirstGenericType(Method method) {
+        Type returnType = method.getGenericReturnType();
+        ParameterizedType parameterizedType = (ParameterizedType) returnType;
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+        Type type = actualTypeArguments[0];
+        if (type instanceof ParameterizedType) {
+            ParameterizedType firstParameterizedType = (ParameterizedType) type;
+            return (Class) firstParameterizedType.getRawType();
+        }
+        return (Class) type;
+    }
+
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
index 4b204c3218c..9514203aa54 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
@@ -20,12 +20,16 @@
 import io.helidon.microprofile.messaging.MessageUtils;
 import io.helidon.microprofile.messaging.channel.ProcessorMethod;
 import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.concurrent.ExecutionException;
 
 /**
  * Process every item in stream by method ex:
@@ -58,20 +62,39 @@ public void onSubscribe(Subscription s) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void onNext(Object incomingValue) {
         try {
-            //TODO: Has to be always one param in the processor, validate and propagate better
             Method method = processorMethod.getMethod();
+            //TODO: Has to be always one param in the processor, validate and propagate better
             Class paramType = method.getParameterTypes()[0];
             Object processedValue = method.invoke(processorMethod.getBeanInstance(),
                     MessageUtils.unwrap(incomingValue, paramType));
-            subscriber.onNext(wrapValue(processedValue));
-        } catch (IllegalAccessException | InvocationTargetException e) {
+            //TODO: Extract as some sensible util
+            if (processedValue instanceof Publisher || processedValue instanceof PublisherBuilder) {
+                //Flatten, we are sure its invoke on every request method now
+                PublisherBuilder publisherBuilder = null;
+                if (processedValue instanceof Publisher) {
+                    publisherBuilder = ReactiveStreams.fromPublisher((Publisher) processedValue);
+                } else {
+                    publisherBuilder = (PublisherBuilder) processedValue;
+                }
+                publisherBuilder.forEach(subVal -> {
+                    try {
+                        subscriber.onNext(wrapValue(subVal));
+                    } catch (ExecutionException | InterruptedException e) {
+                        subscriber.onError(e);
+                    }
+                }).run();
+            } else {
+                subscriber.onNext(wrapValue(processedValue));
+            }
+        } catch (IllegalAccessException | InvocationTargetException | ExecutionException | InterruptedException e) {
             subscriber.onError(e);
         }
     }
 
-    protected Object wrapValue(Object value) {
+    protected Object wrapValue(Object value) throws ExecutionException, InterruptedException {
         return MessageUtils.unwrap(value, Message.class);
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
index bd37d6963ff..96c0204c3a5 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
@@ -61,6 +61,7 @@ public void onNext(Object message) {
             incrementAndCheckChunkPosition();
         } catch (Exception e) {
             //Notify publisher to stop sending
+            // TODO: Maybe should not notify to stop sending, check the spec
             subscription.cancel();
             throw new RuntimeException(e);
         }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
index 03e55521de0..8f7c53e8a21 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
@@ -30,6 +30,7 @@
 import org.reactivestreams.Subscription;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.ExecutionException;
 
 /**
  * Passes publisher to processor method ex:
@@ -90,14 +91,12 @@ public void subscribe(Subscriber s) {
         if (processor != null) {
             // Backed by real  processor
             processor.subscribe(s);
-        } else if (publisher == null) {
-            //Differences between small-rye and Multi impl
-            subscriber = s;
-        } else if (!subscribed) {
+        } else if (!subscribed && publisher != null) {
+            // Backed by publisher
             subscribed = true;
             publisher.subscribe(s);
         } else {
-            throw new DeploymentException("Already subscribed");
+            subscriber = s;
         }
     }
 
@@ -113,12 +112,16 @@ public void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(Object o) {
-        //TODO: Cleanup by assigning processor to publisher and subscriber instead of all those ifs
-        if (processor != null) {
-            // Backed by real  processor
-            processor.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
-        } else {
-            subscriber.onNext(o);
+        try {
+            //TODO: Cleanup by assigning processor to publisher and subscriber instead of all those ifs
+            if (processor != null) {
+                // Backed by real  processor
+                processor.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
+            } else {
+                subscriber.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
+            }
+        }catch (ExecutionException | InterruptedException e){
+            onError(e);
         }
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
index 91156ce646c..cb63aa3adc3 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
@@ -23,6 +23,7 @@
 import org.reactivestreams.Subscription;
 
 import java.lang.reflect.Method;
+import java.util.concurrent.ExecutionException;
 
 /**
  * Unwrap Message payload if incoming method Publisher or Publisher builder
@@ -45,7 +46,7 @@ public static UnwrapProcessor of(Method method, Subscriber subscriber) {
         return unwrapProcessor;
     }
 
-    Object unwrap(Object o) {
+    Object unwrap(Object o) throws ExecutionException, InterruptedException {
         return MessageUtils.unwrap(o, method);
     }
 
@@ -62,7 +63,11 @@ public void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(Object o) {
-        subscriber.onNext(unwrap(o));
+        try {
+            subscriber.onNext(unwrap(o));
+        } catch (ExecutionException | InterruptedException e) {
+            onError(e);
+        }
     }
 
     @Override
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java
new file mode 100644
index 00000000000..5771d209599
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MessageUtilsTest {
+
+    @SuppressWarnings("unchecked")
+    static Stream testSource() {
+        CompletableFuture stringFuture = new CompletableFuture<>();
+        stringFuture.complete("test");
+        CompletableFuture> messageFuture = new CompletableFuture<>();
+        messageFuture.complete(Message.of("test"));
+        return Stream.of(
+
+                Tuple.of("test", String.class),
+                Tuple.of("test", Message.class),
+                Tuple.of(Message.of("test"), String.class),
+                Tuple.of(Message.of(stringFuture), String.class),
+                Tuple.of(messageFuture, String.class),
+                Tuple.of(Message.of(messageFuture), String.class)
+
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testSource")
+    void wrapperTest(Tuple tuple) throws ExecutionException, InterruptedException {
+        assertExpectedType(tuple.value, tuple.type);
+    }
+
+    private static void assertExpectedType(Object value, Class type) throws ExecutionException, InterruptedException {
+        Object unwrapped = MessageUtils.unwrap(value, type);
+        assertTrue(type.isAssignableFrom(unwrapped.getClass()),
+                String.format("Expected value of type %s got %s instead", type.getSimpleName(), value.getClass().getSimpleName()));
+    }
+
+    private static class Tuple {
+        private Object value;
+        private Class type;
+
+        private Tuple(Object value, Class clazz) {
+            this.value = value;
+            this.type = clazz;
+        }
+
+        static Tuple of(Object o, Class clazz) {
+            return new Tuple(o, clazz);
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Class getType() {
+            return type;
+        }
+
+        @Override
+        public String toString() {
+            return value.getClass().getSimpleName() + " -> " + type.getSimpleName();
+        }
+    }
+}
\ No newline at end of file
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV1Bean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV1Bean.java
index 4412ee05971..ecfee767f6d 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PrimitiveProcessorBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV1Bean.java
@@ -28,7 +28,7 @@
 import java.util.stream.IntStream;
 
 @ApplicationScoped
-public class PrimitiveProcessorBean {
+public class ByRequestProcessorV1Bean {
 
     public static CountDownLatch testLatch = new CountDownLatch(10);
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV2Bean.java
new file mode 100644
index 00000000000..73f9cdca757
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV2Bean.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class ByRequestProcessorV2Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-synchronous-payload")
+    public PublisherBuilder streamForProcessorOfPayloads() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-synchronous-payload")
+    @Outgoing("synchronous-payload")
+    public String payloadSynchronous(int value) {
+        return Integer.toString(value + 1);
+    }
+
+    @Incoming("synchronous-payload")
+    public void getMessgesFromProcessorOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV3Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV3Bean.java
new file mode 100644
index 00000000000..d38c5f930e7
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV3Bean.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class ByRequestProcessorV3Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-synchronous-message")
+    public PublisherBuilder streamForProcessorOfMessages() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-synchronous-message")
+    @Outgoing("synchronous-message")
+    public Message messageSynchronous(Message message) {
+        return Message.of(Integer.toString(message.getPayload() + 1));
+    }
+
+    @Incoming("synchronous-message")
+    public void getMessgesFromProcessorOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV4Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV4Bean.java
new file mode 100644
index 00000000000..3c2d6512fbe
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV4Bean.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class ByRequestProcessorV4Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-asynchronous-message")
+    public PublisherBuilder streamForProcessorBuilderOfMessages() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-asynchronous-message")
+    @Outgoing("asynchronous-message")
+    public CompletionStage> messageAsynchronous(Message message) {
+        return CompletableFuture.supplyAsync(() -> Message.of(Integer.toString(message.getPayload() + 1)), Executors.newSingleThreadExecutor());
+    }
+
+    @Incoming("asynchronous-message")
+    public void getMessgesFromProcessorBuilderOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV5Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV5Bean.java
new file mode 100644
index 00000000000..5f275ffc652
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ByRequestProcessorV5Bean.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+
+@ApplicationScoped
+public class ByRequestProcessorV5Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-asynchronous-payload")
+    public PublisherBuilder streamForProcessorBuilderOfPayloads() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-asynchronous-payload")
+    @Outgoing("asynchronous-payload")
+    public CompletionStage payloadAsynchronous(int value) {
+        return CompletableFuture.supplyAsync(() -> Integer.toString(value + 1), Executors.newSingleThreadExecutor());
+    }
+
+    @Incoming("asynchronous-payload")
+    public void getMessgesFromProcessorBuilderOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 2de74ed56cb..95bf6c12180 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -40,34 +40,43 @@ public void setUp() {
     static Stream testCaseSource() {
         return Stream.of(
                 //Positive tests
-                CdiTestCase.from(PublisherBuilderTransformerV2Bean.class),
-                CdiTestCase.from(PublisherBuilderTransformerV1Bean.class),
-                CdiTestCase.from(PublisherFromPublisherV2Bean.class),
-                CdiTestCase.from(PublisherFromPublisherV1Bean.class),
-                CdiTestCase.from(ProcessorBean.class),
-                CdiTestCase.from(ProcessorBuilderBean.class),
-                CdiTestCase.from(PullForEachBean.class),
-                CdiTestCase.from(CompletionStageV1Bean.class),
-                CdiTestCase.from(PublisherPayloadV6Bean.class),
-                CdiTestCase.from(PublisherPayloadV5Bean.class),
-                CdiTestCase.from(PublisherPayloadV4Bean.class),
-                CdiTestCase.from(PublisherPayloadV3Bean.class),
-                CdiTestCase.from(PublisherPayloadV1Bean.class),
-                CdiTestCase.from(PublisherSubscriberBuilderV2Bean.class),
-                CdiTestCase.from(PublisherSubscriberBuilderV1Bean.class),
-                CdiTestCase.from(PublisherSubscriberV2Bean.class),
-                CdiTestCase.from(PublisherSubscriberV1Bean.class),
-                CdiTestCase.from(InternalChannelsBean.class),
-                CdiTestCase.from(InnerProcessorBean.class),
-                CdiTestCase.from(MultipleProcessorBean.class),
-                CdiTestCase.from(MultipleTypeProcessorChainBean.class),
-                CdiTestCase.from(PrimitiveProcessorBean.class),
+                PublisherBuilderTransformerV2Bean.class,
+                PublisherBuilderTransformerV1Bean.class,
+                PublisherFromPublisherV2Bean.class,
+                PublisherFromPublisherV1Bean.class,
+                ProcessorBean.class,
+                ProcessorBuilderBean.class,
+                PullForEachBean.class,
+                CompletionStageV1Bean.class,
+                PublisherPayloadV6Bean.class,
+                PublisherPayloadV5Bean.class,
+                PublisherPayloadV4Bean.class,
+                PublisherPayloadV3Bean.class,
+                PublisherPayloadV1Bean.class,
+                PublisherSubscriberBuilderV2Bean.class,
+                PublisherSubscriberBuilderV1Bean.class,
+                PublisherSubscriberV2Bean.class,
+                PublisherSubscriberV1Bean.class,
+                InternalChannelsBean.class,
+                InnerProcessorBean.class,
+                MultipleProcessorBean.class,
+                MultipleTypeProcessorChainV1Bean.class,
+                MultipleTypeProcessorChainV2Bean.class,
+                ByRequestProcessorV5Bean.class,
+                ByRequestProcessorV4Bean.class,
+                ByRequestProcessorV3Bean.class,
+                ByRequestProcessorV2Bean.class,
+                ByRequestProcessorV1Bean.class,
+                PublisherProcessorV4Bean.class,
+                PublisherProcessorV3Bean.class,
+                PublisherProcessorV2Bean.class,
+                PublisherProcessorV1Bean.class,
 
                 //Negative tests
-                CdiTestCase.from(NotConnectedIncommingChannelBean.class),
-                CdiTestCase.from(NotConnectedOutgoingChannelBean.class),
-                CdiTestCase.from(BadSignaturePublisherPayloadBean.class)
-        );
+                NotConnectedIncommingChannelBean.class,
+                NotConnectedOutgoingChannelBean.class,
+                BadSignaturePublisherPayloadBean.class
+        ).map(CdiTestCase::from);
     }
 
     @ParameterizedTest
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV1Bean.java
similarity index 96%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV1Bean.java
index 01ddfb98102..e3156af2ec4 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV1Bean.java
@@ -33,7 +33,7 @@
 import java.util.stream.Collectors;
 
 @ApplicationScoped
-public class MultipleTypeProcessorChainBean implements CountableTestBean {
+public class MultipleTypeProcessorChainV1Bean implements CountableTestBean {
     public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
     public static Set EXPECTED_DATA = TEST_DATA.stream()
             .map(String::toLowerCase)
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV2Bean.java
new file mode 100644
index 00000000000..7b1f33806f4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/MultipleTypeProcessorChainV2Bean.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.stream.Collectors;
+
+@ApplicationScoped
+public class MultipleTypeProcessorChainV2Bean implements CountableTestBean {
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+    public static Set EXPECTED_DATA = TEST_DATA.stream()
+            .map(String::toLowerCase)
+            .map(s -> s + "-processed")
+            .collect(Collectors.toSet());
+    public static CountDownLatch testLatch = new CountDownLatch(TEST_DATA.size());
+
+    @Outgoing("inner-processor")
+    public Publisher produceMessage() {
+        return MultiRS.just(TEST_DATA.stream());
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-processor-2")
+    public String toUpperCase(String payload) {
+        return payload;
+    }
+
+    @Incoming("inner-processor-2")
+    @Outgoing("inner-processor-3")
+    public PublisherBuilder process(PublisherBuilder msg) {
+        return msg.map(s -> s.toLowerCase());
+    }
+
+    @Incoming("inner-processor-3")
+    @Outgoing("inner-consumer")
+    public String process2(String msg) {
+        return msg + "-processed";
+    }
+
+    @Incoming("inner-consumer")
+    public void receiveMessage(String msg) {
+        if (EXPECTED_DATA.contains(msg)) {
+            testLatch.countDown();
+        }
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java
new file mode 100644
index 00000000000..3d30eb3a363
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class PublisherProcessorV1Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-for-processor-publisher-message")
+    public PublisherBuilder streamForProcessorOfMessages() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-for-processor-publisher-message")
+    @Outgoing("processor-publisher-message")
+    public Publisher> processorOfMessages(Message message) {
+        return ReactiveStreams.of(message)
+                .map(Message::getPayload)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("processor-publisher-message")
+    public void getMessgesFromProcessorOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java
new file mode 100644
index 00000000000..833efcbe58f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class PublisherProcessorV2Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-for-processor-publisher-payload")
+    public PublisherBuilder streamForProcessorOfPayloads() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-for-processor-publisher-payload")
+    @Outgoing("processor-publisher-payload")
+    public Publisher processorOfPayloads(int value) {
+        return ReactiveStreams.of(value)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .buildRs();
+    }
+
+    @Incoming("processor-publisher-payload")
+    public void getMessgesFromProcessorOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java
new file mode 100644
index 00000000000..939e0ab1675
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class PublisherProcessorV3Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-for-processor-publisher-builder-message")
+    public PublisherBuilder streamForProcessorBuilderOfMessages() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-for-processor-publisher-builder-message")
+    @Outgoing("processor-publisher-builder-message")
+    public PublisherBuilder> processorBuilderOfMessages(Message message) {
+        return ReactiveStreams.of(message)
+                .map(Message::getPayload)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i))
+                .map(Message::of);
+    }
+
+    @Incoming("processor-publisher-builder-message")
+    public void getMessgesFromProcessorBuilderOfMessages(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java
new file mode 100644
index 00000000000..349ed251a48
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner;
+
+import io.helidon.microprofile.messaging.CountableTestBean;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import java.util.concurrent.CountDownLatch;
+
+@ApplicationScoped
+public class PublisherProcessorV4Bean implements CountableTestBean {
+
+    public static CountDownLatch testLatch = new CountDownLatch(10);
+
+    @Outgoing("publisher-for-processor-publisher-builder-payload")
+    public PublisherBuilder streamForProcessorBuilderOfPayloads() {
+        return ReactiveStreams.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    }
+
+    @Incoming("publisher-for-processor-publisher-builder-payload")
+    @Outgoing("processor-publisher-builder-payload")
+    public PublisherBuilder processorBuilderOfPayloads(int value) {
+        return ReactiveStreams.of(value)
+                .map(i -> i + 1)
+                .flatMap(i -> ReactiveStreams.of(i, i))
+                .map(i -> Integer.toString(i));
+    }
+
+    @Incoming("processor-publisher-builder-payload")
+    public void getMessgesFromProcessorBuilderOfPayloads(String value) {
+        getTestLatch().countDown();
+    }
+
+    @Override
+    public CountDownLatch getTestLatch() {
+        return testLatch;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
index 34dce21b0a9..391a3f996ab 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
@@ -26,6 +26,7 @@
 import org.reactivestreams.Subscriber;
 
 import java.lang.reflect.Method;
+import java.util.concurrent.ExecutionException;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -56,7 +57,7 @@ static Stream methodSource() {
 
     @ParameterizedTest
     @MethodSource("methodSource")
-    void innerChannelBeanTest(Method method) {
+    void innerChannelBeanTest(Method method) throws ExecutionException, InterruptedException {
         UnwrapProcessor unwrapProcessor = new UnwrapProcessor();
         unwrapProcessor.setMethod(method);
         Object unwrappedValue = unwrapProcessor.unwrap(Message.of("test"));
diff --git a/microprofile/tests/tck/pom.xml b/microprofile/tests/tck/pom.xml
index 4709b82af46..2bbe7a4bb98 100644
--- a/microprofile/tests/tck/pom.xml
+++ b/microprofile/tests/tck/pom.xml
@@ -35,6 +35,7 @@
         tck-health
         tck-metrics
         tck-metrics2
+        tck-messaging
         tck-fault-tolerance
         tck-jwt-auth
         tck-openapi

From 64a7577a85bf805bd5639f3a85722b0449fdb565 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 18 Nov 2019 16:18:51 +0100
Subject: [PATCH 17/66] Naming convention cleanup

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  4 --
 microprofile/messaging/pom.xml                |  8 ++--
 .../messaging/channel/ProcessorMethod.java    |  1 -
 .../messaging/reactive/ProxyProcessor.java    | 40 +++++--------------
 .../messaging/reactive/UnwrapProcessor.java   |  2 -
 microprofile/pom.xml                          |  2 +
 .../pom.xml                                   |  8 +++-
 .../reactive/CompletionSubscriber.java        |  0
 .../reactive/FlatMapProcessor.java            |  0
 .../reactive/HelidonCumulativeProcessor.java  |  0
 .../reactive/HelidonReactiveStreamEngine.java |  0
 .../HelidonSubscriberWithCompletionStage.java |  0
 .../microprofile/reactive/MultiRS.java        |  0
 .../reactive/MultiStagesCollector.java        |  0
 .../reactive/hybrid/HybridProcessor.java      |  0
 .../reactive/hybrid/HybridPublisher.java      |  0
 .../reactive/hybrid/HybridSubscriber.java     |  0
 .../reactive/hybrid/HybridSubscription.java   |  0
 ...treams.operators.spi.ReactiveStreamsEngine |  0
 .../reactive/ConsumableSubscriber.java        |  0
 .../microrofile/reactive/EngineTest.java      |  0
 .../reactive/IntSequencePublisher.java        |  0
 microprofile/tests/tck/tck-messaging/pom.xml  | 13 +-----
 23 files changed, 25 insertions(+), 53 deletions(-)
 rename microprofile/{reactive-bridge => reactive-streams}/pom.xml (90%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/MultiRS.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/test/java/io/helidon/microrofile/reactive/EngineTest.java (100%)
 rename microprofile/{reactive-bridge => reactive-streams}/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java (100%)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 4b1a4433568..0614cc92474 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -112,7 +112,6 @@ public void subscribe(Subscriber s) {
 
     /**
      * Submit an item to the subscriber.
-     *
      * @param item item to be submitted
      */
     protected void submit(U item) {
@@ -134,7 +133,6 @@ protected void submit(U item) {
 
     /**
      * Hook for {@link Subscriber#onNext(java.lang.Object)}.
-     *
      * @param item next item
      */
     protected void hookOnNext(T item) {
@@ -142,7 +140,6 @@ protected void hookOnNext(T item) {
 
     /**
      * Hook for {@link Subscriber#onError(java.lang.Throwable)}.
-     *
      * @param error error received
      */
     protected void hookOnError(Throwable error) {
@@ -162,7 +159,6 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     /**
      * Subscribe the subscriber after the given delegate publisher.
-     *
      * @param delegate delegate publisher
      */
     protected final void doSubscribe(Publisher delegate) {
diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml
index 987116e7e03..7027a43eea5 100644
--- a/microprofile/messaging/pom.xml
+++ b/microprofile/messaging/pom.xml
@@ -26,8 +26,10 @@
     
 
     helidon-microprofile-messaging
-    Helidon Microprofile Messaging
-    The microprofile messaging implementation
+    Helidon MicroProfile Reactive Messaging
+    
+        Helidon MicroProfile Reactive Messaging 1.0
+    
 
     
         
@@ -67,7 +69,7 @@
         
         
             io.helidon.microprofile
-            helidon-microprofile-reactive-bridge
+            helidon-microprofile-reactive-streams
             1.3.2-SNAPSHOT
         
         
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index 4dc48aeb44a..5ad2651eca3 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -55,7 +55,6 @@ public ProcessorMethod(AnnotatedMethod method, ChannelRouter router) {
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
         if (type.isInvokeAtAssembly()) {
-            // TODO: Incoming methods returning custom processor
             processor = new ProxyProcessor(this);
         } else {
             // Create brand new subscriber
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
index 8f7c53e8a21..171f50d5973 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
@@ -23,12 +23,13 @@
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.jboss.weld.exceptions.DeploymentException;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
+import javax.enterprise.inject.spi.DeploymentException;
+
 import java.lang.reflect.InvocationTargetException;
 import java.util.concurrent.ExecutionException;
 
@@ -78,10 +79,10 @@ public ProxyProcessor(ProcessorMethod processorMethod) {
                 publisher = processor;
 
             } else {
-                throw new UnsupportedOperationException("Not implemented yet!");
+                throw new UnsupportedOperationException("Unknown signature type " + processorMethod.getType());
             }
         } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e);
+            throw new DeploymentException(e);
         }
 
     }
@@ -91,6 +92,7 @@ public void subscribe(Subscriber s) {
         if (processor != null) {
             // Backed by real  processor
             processor.subscribe(s);
+            subscriber = processor;
         } else if (!subscribed && publisher != null) {
             // Backed by publisher
             subscribed = true;
@@ -102,46 +104,26 @@ public void subscribe(Subscriber s) {
 
     @Override
     public void onSubscribe(Subscription s) {
-        if (processor != null) {
-            // Backed by real  processor
-            processor.onSubscribe(s);
-        } else {
-            subscriber.onSubscribe(s);
-        }
+        subscriber.onSubscribe(s);
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void onNext(Object o) {
         try {
-            //TODO: Cleanup by assigning processor to publisher and subscriber instead of all those ifs
-            if (processor != null) {
-                // Backed by real  processor
-                processor.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
-            } else {
-                subscriber.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
-            }
-        }catch (ExecutionException | InterruptedException e){
+            subscriber.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
+        } catch (ExecutionException | InterruptedException e) {
             onError(e);
         }
     }
 
     @Override
     public void onError(Throwable t) {
-        if (processor != null) {
-            // Backed by real  processor
-            processor.onError(t);
-        } else {
-            subscriber.onError(t);
-        }
+        subscriber.onError(t);
     }
 
     @Override
     public void onComplete() {
-        if (processor != null) {
-            // Backed by real  processor
-            processor.onComplete();
-        } else {
-            subscriber.onComplete();
-        }
+        subscriber.onComplete();
     }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
index cb63aa3adc3..930203fde1d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
@@ -29,8 +29,6 @@
  * Unwrap Message payload if incoming method Publisher or Publisher builder
  * has generic return type different than Message
  */
-//TODO: Remove and replace with MessageUtils static call
-@Deprecated
 public class UnwrapProcessor implements Processor {
 
     private Method method;
diff --git a/microprofile/pom.xml b/microprofile/pom.xml
index 84b91b91ac2..b2c27dfb927 100644
--- a/microprofile/pom.xml
+++ b/microprofile/pom.xml
@@ -48,5 +48,7 @@
         rest-client
         access-log
         grpc
+        reactive-streams
+        messaging
     
 
diff --git a/microprofile/reactive-bridge/pom.xml b/microprofile/reactive-streams/pom.xml
similarity index 90%
rename from microprofile/reactive-bridge/pom.xml
rename to microprofile/reactive-streams/pom.xml
index 0e6f054674e..f2d44bfee3a 100644
--- a/microprofile/reactive-bridge/pom.xml
+++ b/microprofile/reactive-streams/pom.xml
@@ -28,8 +28,12 @@
     
 
     io.helidon.microprofile
-    helidon-microprofile-reactive-bridge
-    Helidon Reactive Bridge
+    helidon-microprofile-reactive-streams
+    Helidon Microprofile Reactive Streams Operators
+
+    
+        Helidon Microprofile Reactive Streams Operators 1.0
+    
 
     
         
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
diff --git a/microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
similarity index 100%
rename from microprofile/reactive-bridge/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
diff --git a/microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine b/microprofile/reactive-streams/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine
similarity index 100%
rename from microprofile/reactive-bridge/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine
rename to microprofile/reactive-streams/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
similarity index 100%
rename from microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
similarity index 100%
rename from microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
diff --git a/microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
similarity index 100%
rename from microprofile/reactive-bridge/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml
index a73997ea3ae..8089563ec2a 100644
--- a/microprofile/tests/tck/tck-messaging/pom.xml
+++ b/microprofile/tests/tck/tck-messaging/pom.xml
@@ -67,19 +67,13 @@
             io.helidon.microprofile
             helidon-microprofile-messaging
             1.3.2-SNAPSHOT
-
             
                 
                     io.helidon.microprofile
-                    helidon-microprofile-reactive-bridge
+                    helidon-microprofile-reactive-streams
                 
             
         
-
-
-
-
-
         
             io.smallrye.reactive
             smallrye-reactive-streams-operators
@@ -91,11 +85,6 @@
                 
             
         
-
-
-
-
-
     
 
     

From b3b5ba863fe6c987be6d7bca1f442df2c6820cf4 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 19 Nov 2019 16:08:36 +0100
Subject: [PATCH 18/66] Check-style and coverage for:

  * Helidon Microprofile Reactive Streams Operators
  * Helidon Common Reactive

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  53 +++++++-
 .../common/reactive/FilterProcessor.java      |   7 +-
 .../common/reactive/LimitProcessor.java       |  34 ++++-
 .../io/helidon/common/reactive/Multi.java     |  32 +++--
 .../reactive/MultiMappingProcessor.java       |   6 +-
 .../common/reactive/PeekProcessor.java        |  11 +-
 .../io/helidon/common/reactive/MultiTest.java |  70 +++++++++-
 .../messaging/kafka/SimpleKafkaTest.java      |  18 +++
 .../reactive/CompletionSubscriber.java        |  24 ++--
 .../reactive/FlatMapProcessor.java            |  23 ++--
 .../reactive/HelidonCumulativeProcessor.java  |  22 ++--
 .../reactive/HelidonReactiveStreamEngine.java |  21 ++-
 .../HelidonSubscriberWithCompletionStage.java |  45 +++++--
 .../microprofile/reactive/MultiRS.java        |  84 +++++++++---
 .../reactive/MultiStagesCollector.java        | 122 +++++++++++++-----
 .../reactive/hybrid/HybridProcessor.java      |  35 ++++-
 .../reactive/hybrid/HybridPublisher.java      |  30 ++++-
 .../reactive/hybrid/HybridSubscriber.java     |  34 ++++-
 .../reactive/hybrid/HybridSubscription.java   |  32 ++++-
 .../reactive/hybrid/package-info.java         |  23 ++++
 .../microprofile/reactive/package-info.java   |  21 +++
 .../reactive/IntSequencePublisher.java        |   1 -
 22 files changed, 614 insertions(+), 134 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/package-info.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/package-info.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 0614cc92474..236bae06977 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -38,6 +38,9 @@ public abstract class BaseProcessor implements Processor, Subscripti
     private volatile boolean done;
     private Throwable error;
 
+    /**
+     * Generic processor used for the implementation of {@link Multi} and {@link Single}.
+     */
     public BaseProcessor() {
         requested = new RequestedCounter();
         ready = new AtomicBoolean();
@@ -110,8 +113,37 @@ public void subscribe(Subscriber s) {
         }
     }
 
+    /**
+     * Processor's {@link io.helidon.common.reactive.Flow.Subscription} registered by
+     * {@link BaseProcessor#onSubscribe(io.helidon.common.reactive.Flow.Subscription)}.
+     *
+     * @return {@link io.helidon.common.reactive.Flow.Subscription}
+     */
+    protected Subscription getSubscription() {
+        return subscription;
+    }
+
+    /**
+     * Processor's {@link SingleSubscriberHolder}.
+     *
+     * @return {@link SingleSubscriberHolder}
+     */
+    protected SingleSubscriberHolder getSubscriber() {
+        return subscriber;
+    }
+
+    /**
+     * Returns {@link RequestedCounter} with information about requested vs. submitted items.
+     *
+     * @return {@link RequestedCounter}
+     */
+    protected RequestedCounter getRequestedCounter() {
+        return requested;
+    }
+
     /**
      * Submit an item to the subscriber.
+     *
      * @param item item to be submitted
      */
     protected void submit(U item) {
@@ -133,6 +165,7 @@ protected void submit(U item) {
 
     /**
      * Hook for {@link Subscriber#onNext(java.lang.Object)}.
+     *
      * @param item next item
      */
     protected void hookOnNext(T item) {
@@ -140,6 +173,7 @@ protected void hookOnNext(T item) {
 
     /**
      * Hook for {@link Subscriber#onError(java.lang.Throwable)}.
+     *
      * @param error error received
      */
     protected void hookOnError(Throwable error) {
@@ -152,13 +186,16 @@ protected void hookOnComplete() {
     }
 
     /**
-     * Hook for {@link Flow.Subscription#cancel()}.
+     * Hook for {@link SingleSubscriberHolder#cancel()}.
+     *
+     * @param subscription of the processor for optional passing cancel event
      */
     protected void hookOnCancel(Flow.Subscription subscription) {
     }
 
     /**
      * Subscribe the subscriber after the given delegate publisher.
+     *
      * @param delegate delegate publisher
      */
     protected final void doSubscribe(Publisher delegate) {
@@ -192,6 +229,9 @@ private void completeOnError(Subscriber sub, Throwable ex) {
         sub.onError(ex);
     }
 
+    /**
+     * Try close processor's subscriber.
+     */
     protected void tryComplete() {
         if (ready.get() && !subscriber.isClosed()) {
             if (error != null) {
@@ -208,11 +248,16 @@ protected void tryComplete() {
         }
     }
 
-    private void tryRequest(Subscription s) {
-        if (s != null && !subscriber.isClosed()) {
+    /**
+     * Responsible for calling {@link io.helidon.common.reactive.Flow.Subscription#request(long)}.
+     *
+     * @param subscription {@link io.helidon.common.reactive.Flow.Subscription} to make a request from
+     */
+    protected void tryRequest(Subscription subscription) {
+        if (subscription != null && !subscriber.isClosed()) {
             long n = requested.get();
             if (n > 0) {
-                s.request(n);
+                subscription.request(n);
             }
         }
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 00e39aa762c..36bd700db10 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -20,14 +20,17 @@
 import java.util.function.Predicate;
 
 /**
- * Processor filtering stream with supplied predicate
- *
+ * Processor filtering stream with supplied predicate.
  * @param  both input/output type
  */
 public class FilterProcessor extends BaseProcessor implements Multi {
 
     private Predicate predicate;
 
+    /**
+     * Processor filtering stream with supplied predicate.
+     * @param predicate provided predicate to filter stream with
+     */
     public FilterProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index d2f3ab3b10b..61c2c392bd3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -20,7 +20,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
- * Invoke supplied consumer for every item in the stream
+ * Let pass only specified number of items.
  *
  * @param  both input/output type
  */
@@ -28,16 +28,38 @@ public class LimitProcessor extends BaseProcessor implements Multi {
 
     private final AtomicLong counter;
 
+    /**
+     * Processor with specified number of allowed items.
+     *
+     * @param limit number of items to pass
+     */
     public LimitProcessor(Long limit) {
         counter = new AtomicLong(limit);
     }
 
+
+    @Override
+    protected void tryRequest(Flow.Subscription s) {
+        if (s != null && !getSubscriber().isClosed()) {
+            long n = getRequestedCounter().get();
+            if (n > 0) {
+                //Request one by one with limit
+                s.request(1);
+            }
+        }
+    }
+
     @Override
     protected void hookOnNext(T item) {
-        if (0 < counter.getAndDecrement()) {
+        long actCounter = this.counter.getAndDecrement();
+        if (0 < actCounter) {
             submit(item);
-        } else {
-            tryComplete();
+            if (1 < actCounter) {
+                // Don't request after last run
+                tryRequest(getSubscription());
+            } else {
+                tryComplete();
+            }
         }
     }
 
@@ -48,8 +70,6 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     public String toString() {
-        return "LimitProcessor{" +
-                "counter=" + counter +
-                '}';
+        return "LimitProcessor{" + "counter=" + counter + '}';
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index ae131da1b4d..7494ad1d5ab 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -46,43 +46,51 @@ default  Multi map(Mapper mapper) {
     }
 
     /**
-     * Invoke provided consumer for every item in stream
+     * Invoke provided consumer for every item in stream.
      *
      * @param consumer consumer to be invoked
-     * @param  consumer argument type
      * @return Multi
      */
-    default  Multi peek(Consumer consumer) {
-        PeekProcessor processor = new PeekProcessor(consumer);
+    default Multi peek(Consumer consumer) {
+        PeekProcessor processor = new PeekProcessor(consumer);
         this.subscribe(processor);
         return processor;
     }
 
     /**
-     * Filter stream items with provided predicate
+     * Filter stream items with provided predicate.
      *
      * @param predicate predicate to filter stream with
-     * @param  type of the predicate argument
      * @return Multi
      */
-    default  Multi filter(Predicate predicate) {
-        FilterProcessor processor = new FilterProcessor(predicate);
+    default Multi filter(Predicate predicate) {
+        FilterProcessor processor = new FilterProcessor<>(predicate);
         this.subscribe(processor);
         return processor;
     }
 
     /**
-     * Limit stream to allow only specified number of items to pass
+     * Limit stream to allow only specified number of items to pass.
      *
-     * @param supplier with expected number of items to be produced
+     * @param limit with expected number of items to be produced
      * @return Multi
      */
-    default  Multi limit(Long limit) {
-        LimitProcessor processor = new LimitProcessor(limit);
+    default Multi limit(long limit) {
+        LimitProcessor processor = new LimitProcessor<>(limit);
         this.subscribe(processor);
         return processor;
     }
 
+    /**
+     * Terminal stage, invokes provided consumer for every item in the stream.
+     *
+     * @param consumer consumer to be invoked for each item
+     */
+    default void forEach(Consumer consumer) {
+        FunctionalSubscriber subscriber = new FunctionalSubscriber<>(consumer, null, null, null);
+        this.subscribe(subscriber);
+    }
+
     /**
      * Collect the items of this {@link Multi} instance into a {@link Single} of {@link List}.
      *
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
index 983544329f6..2e2c2df8d93 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
@@ -30,7 +30,11 @@ final class MultiMappingProcessor extends BaseProcessor implements M
 
     private final Mapper mapper;
 
-    MultiMappingProcessor(Mapper mapper) {
+    /**
+     * Processor of {@link Publisher} to {@link Single} that publishes and maps each received item.
+     * @param mapper supplied for all items to be mapped with
+     */
+    public MultiMappingProcessor(Mapper mapper) {
         this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
index e9890bf5ab7..54009b89d66 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
@@ -20,7 +20,7 @@
 import java.util.function.Consumer;
 
 /**
- * Invoke supplied consumer for every item in the stream
+ * Invoke supplied consumer for every item in the stream.
  *
  * @param  both input/output type
  */
@@ -28,6 +28,11 @@ public class PeekProcessor extends BaseProcessor implements Multi {
 
     private Consumer consumer;
 
+    /**
+     * Invoke supplied consumer for every item in the stream.
+     *
+     * @param consumer supplied consumer to be invoke for every item
+     */
     public PeekProcessor(Consumer consumer) {
         this.consumer = consumer;
     }
@@ -45,8 +50,6 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     public String toString() {
-        return "PeekProcessor{" +
-                "consumer=" + consumer +
-                '}';
+        return "PeekProcessor{" + "consumer=" + consumer + '}';
     }
 }
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index dcf423091d0..f83f5b467b2 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -15,10 +15,13 @@
  */
 package io.helidon.common.reactive;
 
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Collections;
 import java.util.concurrent.Flow.Subscription;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 import io.helidon.common.mapper.Mapper;
 
 import org.junit.jupiter.api.Test;
@@ -245,6 +248,71 @@ public String map(String item) {
         assertThat(subscriber.getItems(), is(empty()));
     }
 
+    @Test
+    void testPeekInt() {
+        AtomicInteger sum1 = new AtomicInteger();
+        AtomicInteger sum2 = new AtomicInteger();
+        Multi.just(1, 2, 3)
+                .peek(sum1::addAndGet)
+                .forEach(sum2::addAndGet);
+
+        assertThat(sum1.get(), is(equalTo(1 + 2 + 3)));
+        assertThat(sum1.get(), is(equalTo(sum2.get())));
+    }
+
+    @Test
+    void testPeekString() {
+        StringBuilder sbBefore = new StringBuilder();
+        AtomicInteger sum = new AtomicInteger();
+        Multi.just("1", "2", "3")
+                .peek(sbBefore::append)
+                .map(Integer::parseInt)
+                .forEach(sum::addAndGet);
+        assertThat(sbBefore.toString(), is(equalTo("123")));
+        assertThat(sum.get(), is(equalTo(1 + 2 + 3)));
+    }
+
+    @Test
+    void testFilter() {
+        StringBuilder sbBefore = new StringBuilder();
+        AtomicInteger sum = new AtomicInteger();
+        Multi.just("1", "2", "3")
+                .peek(sbBefore::append)
+                .map(Integer::parseInt)
+                .filter(i -> i != 2)
+                .forEach(sum::addAndGet);
+        assertThat(sbBefore.toString(), is(equalTo("123")));
+        assertThat(sum.get(), is(equalTo(1 + 3)));
+    }
+
+    @Test
+    void testLimit() {
+        final List TEST_DATA = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 9);
+        final long TEST_LIMIT = 3;
+        final int EXPECTED_SUM = 1 + 2 + 3;
+
+        AtomicInteger multiSum1 = new AtomicInteger();
+        AtomicInteger multiSum2 = new AtomicInteger();
+
+        Multi.just(TEST_DATA)
+                .peek(multiSum1::addAndGet)
+                .limit(TEST_LIMIT)
+                .forEach(multiSum2::addAndGet);
+
+        AtomicInteger streamSum1 = new AtomicInteger();
+        AtomicInteger streamSum2 = new AtomicInteger();
+
+        TEST_DATA.stream()
+                .peek(streamSum1::addAndGet)
+                .limit(TEST_LIMIT)
+                .forEach(streamSum2::addAndGet);
+
+        assertThat(multiSum1.get(), is(equalTo(EXPECTED_SUM)));
+        assertThat(multiSum2.get(), is(equalTo(EXPECTED_SUM)));
+        assertThat(streamSum1.get(), is(equalTo(EXPECTED_SUM)));
+        assertThat(streamSum2.get(), is(equalTo(EXPECTED_SUM)));
+    }
+
     private static class MultiTestSubscriber extends TestSubscriber {
 
         @Override
diff --git a/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
index 862ab087b8b..964f7454414 100644
--- a/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
+++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
@@ -1,3 +1,21 @@
+
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.messaging.kafka;
 
 import com.salesforce.kafka.test.junit5.SharedKafkaTestResource;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
index d446b0a4659..eeb11ee2de3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
@@ -17,25 +17,33 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.concurrent.CompletionStage;
+
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.util.concurrent.CompletionStage;
-
 /**
- * Replacement for buggy DefaultCompletionSubscriber
+ * Replacement for non redeeming {@link org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber}'s DefaultCompletionSubscriber.
  * 

- * https://github.com/eclipse/microprofile-reactive-streams-operators/issues/129#issue-521492223
  *
- * @param 
- * @param 
+ * @param  {@link org.reactivestreams.Subscriber} item type
+ * @param  {@link java.util.concurrent.CompletionStage} payload type
+ * @see microprofile-reactive-streams-operators #129
  */
-public class CompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
+class CompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
 
     private final Subscriber subscriber;
     private final CompletionStage completion;
 
-    public static  CompletionSubscriber of(Subscriber subscriber, CompletionStage completion) {
+    /**
+     * Create a {@link io.helidon.microprofile.reactive.CompletionSubscriber} by combining the given subscriber and completion stage.
+     * The objects passed to this method should not be associated with more than one stream instance.
+     *
+     * @param subscriber subscriber to associate with completion stage
+     * @param completion completion stage to associate with subscriber
+     * @return {@link io.helidon.microprofile.reactive.CompletionSubscriber}
+     */
+    static  CompletionSubscriber of(Subscriber subscriber, CompletionStage completion) {
         return new CompletionSubscriber<>(subscriber, completion);
     }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index c7582a2099f..05bc688e8d6 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -17,21 +17,29 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
+
 import io.helidon.common.reactive.BaseProcessor;
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.Multi;
+
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.reactivestreams.Publisher;
 
-import java.util.concurrent.ExecutionException;
-import java.util.function.Function;
-
+/**
+ * Flatten the elements emitted by publishers produced by the mapper function to this stream.
+ */
 public class FlatMapProcessor extends BaseProcessor implements Multi {
 
     private final Function mapper;
-    private Flow.Subscriber subscriber;
 
+    /**
+     * Flatten the elements emitted by publishers produced by the mapper function to this stream.
+     * @param mapper publisher to flatten his data to this stream
+     */
+    @SuppressWarnings("unchecked")
     public FlatMapProcessor(Function mapper) {
         this.mapper = (Function) mapper;
     }
@@ -44,7 +52,7 @@ protected void hookOnNext(Object item) {
         try {
             ReactiveStreams
                     .fromPublisher(publisher)
-                    .forEach(subItem -> submit(subItem))
+                    .forEach(this::submit)
                     .run().toCompletableFuture().get();
         } catch (InterruptedException | ExecutionException e) {
             onError(e);
@@ -59,9 +67,6 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     public String toString() {
-        return "FlatMapProcessor{" +
-                "mapper=" + mapper +
-                ", subscriber=" + subscriber +
-                '}';
+        return String.format("FlatMapProcessor{mapper=%s}", mapper);
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
index c8d84b00062..9e06561a67d 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
@@ -17,21 +17,28 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.LinkedList;
+import java.util.List;
+
 import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
+/**
+ * {@link org.reactivestreams.Processor} wrapping ordered list of {@link org.reactivestreams.Processor}s.
+ */
 public class HelidonCumulativeProcessor implements Processor {
     private LinkedList> processorList = new LinkedList<>();
-    private Processor subscriber;
 
-    public HelidonCumulativeProcessor(List> precedingProcessorList) {
+    /**
+     * Create {@link org.reactivestreams.Processor} wrapping ordered list of {@link io.helidon.common.reactive.Flow.Processor}s.
+     *
+     * @param precedingProcessorList ordered list of {@link io.helidon.common.reactive.Flow.Processor}s
+     */
+    HelidonCumulativeProcessor(List> precedingProcessorList) {
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
     }
@@ -45,8 +52,7 @@ public void subscribe(Subscriber s) {
     public void onSubscribe(Subscription subscription) {
         // This is the time for connecting all processors
         Processor lastProcessor = null;
-        for (Iterator> it = processorList.iterator(); it.hasNext(); ) {
-            Processor processor = it.next();
+        for (Processor processor : processorList) {
             if (lastProcessor != null) {
                 lastProcessor.subscribe(processor);
             }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 34cd26edd6d..50c1d65cf42 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -17,6 +17,11 @@
 
 package io.helidon.microprofile.reactive;
 
+
+import java.util.Collection;
+import java.util.concurrent.CompletionStage;
+import java.util.logging.Logger;
+
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
@@ -25,15 +30,18 @@
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 
-import java.util.Collection;
-import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
-
+/**
+ * Implementation of {@link org.reactivestreams Reactive Streams} with operators
+ * backed by {@link io.helidon.common.reactive Helidon reactive streams}.
+ *
+ * @see org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine
+ */
 public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
 
     private static final Logger LOGGER = Logger.getLogger(HelidonReactiveStreamEngine.class.getName());
 
     @Override
+    @SuppressWarnings("unchecked")
     public  Publisher buildPublisher(Graph graph) throws UnsupportedStageException {
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector<>();
         Collection stages = graph.getStages();
@@ -42,6 +50,7 @@ public  Publisher buildPublisher(Graph graph) throws UnsupportedStageExcep
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public  SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException {
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
@@ -49,6 +58,7 @@ public  SubscriberWithCompletionStage buildSubscriber(Graph graph) t
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public  Processor buildProcessor(Graph graph) throws UnsupportedStageException {
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
@@ -56,10 +66,11 @@ public  Processor buildProcessor(Graph graph) throws UnsupportedStag
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public  CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException {
         MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
         graph.getStages().stream().collect(multiStagesCollector);
-        CompletionStage completionStage = (CompletionStage) multiStagesCollector.getCompletableStage();
+        CompletionStage completionStage = (CompletionStage) multiStagesCollector.getCompletionStage();
         return completionStage;
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
index e3d780fb43d..bcffec6d4eb 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
@@ -17,22 +17,28 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+
 import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.BiConsumer;
-
+/**
+ * Subscriber with preceding processors included,
+ * automatically makes all downstream subscriptions when its subscribe method is called.
+ *
+ * @param  type of streamed item
+ */
 public class HelidonSubscriberWithCompletionStage implements SubscriberWithCompletionStage {
 
     private final Processor connectingProcessor;
@@ -43,12 +49,16 @@ public class HelidonSubscriberWithCompletionStage implements SubscriberWithCo
 
 
     /**
-     * Subscriber with preceding processors included, automatically makes all downstream subscriptions when its subscribe method is called.
+     * Subscriber with preceding processors included,
+     * automatically makes all downstream subscriptions when its subscribe method is called.
      *
-     * @param collectStage
-     * @param precedingProcessorList
+     * @param collectStage {@link org.eclipse.microprofile.reactive.streams.operators.spi.Stage.Collect}
+     *                     for example {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}
+     * @param precedingProcessorList ordered list of preceding processors(needed for automatic subscription in case of incomplete graph)
      */
-    public HelidonSubscriberWithCompletionStage(Stage.Collect collectStage, List> precedingProcessorList) {
+    @SuppressWarnings("unchecked")
+    HelidonSubscriberWithCompletionStage(Stage.Collect collectStage,
+                                         List> precedingProcessorList) {
         this.collectStage = collectStage;
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
@@ -62,10 +72,12 @@ public CompletionStage getCompletion() {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public Subscriber getSubscriber() {
         return (Subscriber) connectingProcessor;
     }
 
+
     private Subscriber prepareSubscriber() {
         return new Subscriber() {
 
@@ -79,6 +91,7 @@ public void onSubscribe(Subscription s) {
             }
 
             @Override
+            @SuppressWarnings("unchecked")
             public void onNext(Object t) {
                 if (!closed.get()) {
                     BiConsumer accumulator = (BiConsumer) collectStage.getCollector().accumulator();
@@ -101,6 +114,11 @@ public void onComplete() {
         };
     }
 
+    /**
+     * Artificial processor, in case of incomplete graph does subscriptions downstream automatically.
+     *
+     * @return Artificial {@link org.reactivestreams.Processor}
+     */
     private Processor prepareConnectingProcessor() {
         return new Processor() {
             @Override
@@ -112,8 +130,7 @@ public void subscribe(Subscriber s) {
             public void onSubscribe(Subscription s) {
                 // This is a time for connecting all pre-processors and subscriber
                 Processor lastProcessor = null;
-                for (Iterator> it = processorList.iterator(); it.hasNext(); ) {
-                    Processor processor = it.next();
+                for (Processor processor : processorList) {
                     if (lastProcessor != null) {
                         lastProcessor.subscribe(processor);
                     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
index d62b73b1cb8..83382efca43 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
@@ -17,50 +17,104 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.Multi;
 import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
 /**
- * Conversion methods between Helidon reactive streams and the "Reactive Streams"
+ * Conversion methods between {@link io.helidon.common.reactive Helidon reactive streams} and the {@link org.reactivestreams Reactive Streams}.
+ * Wraps publishers/processors/subscribers to Hybrid {@link io.helidon.microprofile.reactive.hybrid} variants
  */
 public interface MultiRS {
 
-    public static  Flow.Subscriber from(Subscriber subscriber) {
+    /**
+     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber}
+     * from {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}.
+     *
+     * @param subscriber {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
+     * @param         type of streamed item
+     * @return {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber}
+     */
+    static  Flow.Subscriber from(Subscriber subscriber) {
         return HybridSubscriber.from(subscriber);
     }
 
-    public static  Subscriber from(Flow.Subscriber subscriber) {
+    /**
+     * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
+     * from {@link io.helidon.common.reactive Helidon reactive streams} subscriber.
+     *
+     * @param subscriber Helidon {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Subscriber}
+     * @param         type of streamed item
+     * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
+     */
+    static  Subscriber from(Flow.Subscriber subscriber) {
         return HybridSubscriber.from(subscriber);
     }
 
-    public static  Flow.Publisher from(Publisher publisher) {
+    /**
+     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Publisher}
+     * from {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}.
+     *
+     * @param publisher {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     * @param        type of streamed item
+     * @return Multi stream {@link io.helidon.common.reactive.Flow.Publisher}
+     */
+    static  Flow.Publisher from(Publisher publisher) {
         return HybridPublisher.from(publisher);
     }
 
-    public static  Publisher from(Flow.Publisher publisher) {
+    /**
+     * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     * from {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Publisher}.
+     *
+     * @param publisher {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Publisher}
+     * @param        type of streamed item
+     * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     */
+    static  Publisher from(Flow.Publisher publisher) {
         return HybridPublisher.from(publisher);
     }
 
-    public static  Multi toMulti(Publisher publisher) {
+    /**
+     * Create Helidon {@link io.helidon.common.reactive.Multi} stream
+     * from {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}.
+     *
+     * @param publisher {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     * @param        type of streamed item
+     * @return {@link io.helidon.common.reactive.Multi} stream
+     */
+    static  Multi toMulti(Publisher publisher) {
         return Multi.from(HybridPublisher.from(publisher));
     }
 
-    public static  Multi toMulti(Flow.Publisher publisher) {
-        return Multi.from(publisher);
-    }
-
-    public static  Publisher just(Stream stream) {
+    /**
+     * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     * from Java {@link java.util.stream.Stream}.
+     *
+     * @param stream Java {@link java.util.stream.Stream}
+     * @param     type of streamed item
+     * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     */
+    static  Publisher just(Stream stream) {
         return MultiRS.from(Multi.just(stream.collect(Collectors.toList())));
     }
 
-    public static  Publisher just(U... items) {
+    /**
+     * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     * from items vararg.
+     *
+     * @param items items varargs to be streamed
+     * @param    type of streamed items
+     * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+     */
+    static  Publisher just(U... items) {
         return MultiRS.from(Multi.just(items));
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index 2f52bce705e..e5569b8e3b2 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -16,21 +16,6 @@
 
 package io.helidon.microprofile.reactive;
 
-import io.helidon.common.reactive.FilterProcessor;
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.LimitProcessor;
-import io.helidon.common.reactive.Multi;
-import io.helidon.common.reactive.MultiMappingProcessor;
-import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
-import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
-import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
-import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
-import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
@@ -48,7 +33,32 @@
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
-public class MultiStagesCollector implements Collector, CompletionStage> {
+import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.LimitProcessor;
+import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.MultiMappingProcessor;
+import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
+import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
+import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+
+/**
+ * Collect {@link org.reactivestreams Reactive Streams}
+ * {@link org.eclipse.microprofile.reactive.streams.operators.spi.Stage Stages}
+ * to {@link org.reactivestreams.Publisher}, {@link org.reactivestreams.Processor}
+ * or {@link org.reactivestreams.Subscriber}.
+ *
+ * @param 
+ */
+class MultiStagesCollector implements Collector, CompletionStage> {
 
     private Multi multi = null;
     private List> processorList = new ArrayList<>();
@@ -60,8 +70,8 @@ public Supplier> supplier() {
         return () -> multi != null ? multi : Multi.empty();
     }
 
+    @SuppressWarnings("unchecked")
     private void subscribeUpStream() {
-        // If producer was supplied
         if (multi != null) {
             for (Flow.Processor p : processorList) {
                 multi.subscribe(p);
@@ -72,37 +82,29 @@ private void subscribeUpStream() {
         }
     }
 
-    public Publisher getPublisher() {
-        subscribeUpStream();
-        return MultiRS.from(multi);
-    }
-
     @Override
+    @SuppressWarnings("unchecked")
     public BiConsumer, Stage> accumulator() {
         //MP Stages to Helidon multi streams mapping
         return (m, stage) -> {
 
-            // Create stream
             if (stage instanceof Stage.PublisherStage) {
                 Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage;
                 Publisher rsPublisher = (Publisher) publisherStage.getRsPublisher();
                 multi = MultiRS.toMulti(rsPublisher);
 
             } else if (stage instanceof Stage.Of) {
-                //Collection
                 Stage.Of stageOf = (Stage.Of) stage;
                 List fixedData = StreamSupport.stream(stageOf.getElements().spliterator(), false)
                         .collect(Collectors.toList());
                 multi = (Multi) Multi.just(fixedData);
 
             } else if (stage instanceof Stage.Map) {
-                // Transform stream
                 Stage.Map mapStage = (Stage.Map) stage;
                 Function mapper = (Function) mapStage.getMapper();
                 processorList.add(new MultiMappingProcessor<>(mapper::apply));
 
             } else if (stage instanceof Stage.Filter) {
-                //Filter stream
                 Stage.Filter stageFilter = (Stage.Filter) stage;
                 Predicate predicate = (Predicate) stageFilter.getPredicate();
                 processorList.add(new FilterProcessor(predicate));
@@ -110,7 +112,7 @@ public BiConsumer, Stage> accumulator() {
             } else if (stage instanceof Stage.Peek) {
                 Stage.Peek peekStage = (Stage.Peek) stage;
                 Consumer peekConsumer = (Consumer) peekStage.getConsumer();
-                processorList.add(new PeekProcessor(peekConsumer::accept));
+                processorList.add(new PeekProcessor(peekConsumer));
 
             } else if (stage instanceof Stage.Limit) {
                 Stage.Limit limitStage = (Stage.Limit) stage;
@@ -122,7 +124,6 @@ public BiConsumer, Stage> accumulator() {
                 processorList.add(new FlatMapProcessor(mapper));
 
             } else if (stage instanceof Stage.SubscriberStage) {
-                //Subscribe to stream
                 Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
                 Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
                 this.completionStage = new CompletableFuture<>();
@@ -136,7 +137,7 @@ public BiConsumer, Stage> accumulator() {
                 Stage.Collect collectStage = (Stage.Collect) stage;
                 this.subscriberWithCompletionStage = new HelidonSubscriberWithCompletionStage<>(collectStage, processorList);
                 // If producer was supplied
-                if(multi != null){
+                if (multi != null) {
                     multi.subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
                 }
 
@@ -153,7 +154,7 @@ public BinaryOperator> combiner() {
 
     @Override
     public Function, CompletionStage> finisher() {
-        return t -> getCompletableStage();
+        return t -> getCompletionStage();
     }
 
     @Override
@@ -161,15 +162,70 @@ public Set characteristics() {
         return new HashSet<>(Collections.singletonList(Characteristics.IDENTITY_FINISH));
     }
 
-    public  SubscriberWithCompletionStage getSubscriberWithCompletionStage() {
+    /**
+     * Return subscriber from even incomplete graph,
+     * in case of incomplete graph does subscriptions downstream automatically in the
+     * {@link io.helidon.microprofile.reactive.HelidonSubscriberWithCompletionStage}.
+     *
+     * @param  type of items subscriber consumes
+     * @param  type of items subscriber emits
+     * @return {@link org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage}
+     */
+    @SuppressWarnings("unchecked")
+     SubscriberWithCompletionStage getSubscriberWithCompletionStage() {
         return (SubscriberWithCompletionStage) subscriberWithCompletionStage;
     }
 
-    public  CompletionStage getCompletableStage() {
+    /**
+     * Return {@link java.util.concurrent.CompletionStage}
+     * either from supplied {@link org.reactivestreams.Subscriber}
+     * for example by {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}
+     * or from completion stage for example
+     * {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}.
+     *
+     * @param  type of items subscriber consumes
+     * @return {@link io.helidon.microprofile.reactive.HelidonSubscriberWithCompletionStage}
+     */
+    @SuppressWarnings("unchecked")
+     CompletionStage getCompletionStage() {
         return (CompletionStage) (completionStage != null ? completionStage : subscriberWithCompletionStage.getCompletion());
     }
 
-    public  Processor getProcessor() {
+    /**
+     * Return {@link org.reactivestreams.Processor} wrapping all processor stages from processor builder.
+     * 
See example:
+     * 
{@code
+     *   Processor processor = ReactiveStreams.builder()
+     *       .map(i -> i + 1)
+     *       .flatMap(i -> ReactiveStreams.of(i, i))
+     *       .map(i -> Integer.toString(i))
+     *       .buildRs();
+     * }

+     *
+     * @param  type of items subscriber consumes
+     * @param  type of items subscriber emits
+     * @return {@link org.reactivestreams.Processor} wrapping all processor stages
+     */
+    @SuppressWarnings("unchecked")
+     Processor getProcessor() {
         return (Processor) new HelidonCumulativeProcessor(processorList);
     }
+
+    /**
+     * Returns {@link org.reactivestreams.Publisher} made from supplied stages.
+     * 
See example:
+     * 
{@code
+     *   ReactiveStreams
+     *      .of("10", "20", "30")
+     *      .map(a -> a.replaceAll("0", ""))
+     *      .map(Integer::parseInt)
+     *      .buildRs()
+     * }

+     *
+     * @return {@link org.reactivestreams.Publisher}
+     */
+    Publisher getPublisher() {
+        subscribeUpStream();
+        return MultiRS.from(multi);
+    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
index 6c942d6952f..0658fc46c96 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
@@ -17,13 +17,22 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
+import java.security.InvalidParameterException;
+
 import io.helidon.common.reactive.Flow;
+
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.security.InvalidParameterException;
-
+/**
+ * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Processor}
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Processor},
+ * to be used interchangeably.
+ *
+ * @param  type of items processor consumes
+ * @param  type of items processor emits
+ */
 public class HybridProcessor implements Flow.Processor, Processor {
     private Processor reactiveProcessor;
     private Flow.Processor flowProcessor;
@@ -36,10 +45,32 @@ private HybridProcessor(Flow.Processor processor) {
         this.flowProcessor = processor;
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
+     * from {@link io.helidon.common.reactive.Flow.Processor}.
+     *
+     * @param processor {@link io.helidon.common.reactive.Flow.Processor} to wrap
+     * @param        type of items processor consumes
+     * @param        type of items processor emits
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridProcessor from(Flow.Processor processor) {
         return new HybridProcessor(processor);
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
+     * from {@link org.reactivestreams.Processor}.
+     *
+     * @param processor {@link org.reactivestreams.Processor} to wrap
+     * @param        type of items processor consumes
+     * @param        type of items processor emits
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridProcessor from(Processor processor) {
         return new HybridProcessor(processor);
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
index 65b3271daaf..1bf63bbb32b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
@@ -18,9 +18,17 @@
 package io.helidon.microprofile.reactive.hybrid;
 
 import io.helidon.common.reactive.Flow;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
+/**
+ * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Publisher},
+ * to be used interchangeably.
+ *
+ * @param  type of items
+ */
 public class HybridPublisher implements Flow.Publisher, Publisher {
 
     private Flow.Publisher flowPublisher;
@@ -34,10 +42,30 @@ private HybridPublisher(Publisher reactivePublisher) {
         this.reactivePublisher = reactivePublisher;
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
+     * from {@link io.helidon.common.reactive.Flow.Publisher}.
+     *
+     * @param publisher {@link io.helidon.common.reactive.Flow.Publisher} to wrap
+     * @param        type of items
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridPublisher from(Publisher publisher) {
         return new HybridPublisher(publisher);
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
+     * from {@link org.reactivestreams.Publisher}.
+     *
+     * @param publisher {@link org.reactivestreams.Publisher} to wrap
+     * @param        type of items
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridPublisher from(Flow.Publisher publisher) {
         return new HybridPublisher(publisher);
     }
@@ -49,6 +77,6 @@ public void subscribe(Flow.Subscriber subscriber) {
 
     @Override
     public void subscribe(Subscriber subscriber) {
-       flowPublisher.subscribe(HybridSubscriber.from(subscriber));
+        flowPublisher.subscribe(HybridSubscriber.from(subscriber));
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 5e5187fb9e2..4088d6059a0 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -17,13 +17,21 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
+import java.security.InvalidParameterException;
+import java.util.Objects;
+
 import io.helidon.common.reactive.Flow;
+
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.security.InvalidParameterException;
-import java.util.Objects;
-
+/**
+ * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber},
+ * to be used interchangeably.
+ *
+ * @param  type of items
+ */
 public class HybridSubscriber implements Flow.Subscriber, Subscriber {
 
     private Flow.Subscriber flowSubscriber;
@@ -37,11 +45,31 @@ private HybridSubscriber(Subscriber subscriber) {
         this.reactiveSubscriber = subscriber;
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
+     * from {@link io.helidon.common.reactive.Flow.Subscriber}.
+     *
+     * @param subscriber {@link io.helidon.common.reactive.Flow.Subscriber} to wrap
+     * @param         type of items
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridSubscriber from(Flow.Subscriber subscriber) {
         Objects.requireNonNull(subscriber);
         return new HybridSubscriber(subscriber);
     }
 
+    /**
+     * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
+     * from {@link org.reactivestreams.Subscriber}.
+     *
+     * @param subscriber {@link org.reactivestreams.Subscriber} to wrap
+     * @param        type of items
+     * @return {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static  HybridSubscriber from(Subscriber subscriber) {
         Objects.requireNonNull(subscriber);
         return new HybridSubscriber(subscriber);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
index 151475a8aae..e4b93d516ae 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
@@ -17,15 +17,21 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
+import java.security.InvalidParameterException;
+
 import io.helidon.common.reactive.Flow;
-import org.reactivestreams.Subscription;
 
-import java.security.InvalidParameterException;
+import org.reactivestreams.Subscription;
 
+/**
+ * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscription}
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscription},
+ * to be used interchangeably.
+ */
 public class HybridSubscription implements Flow.Subscription, Subscription {
 
-    Flow.Subscription flowSubscription;
-    Subscription reactiveSubscription;
+    private Flow.Subscription flowSubscription;
+    private Subscription reactiveSubscription;
 
     private HybridSubscription(Flow.Subscription flowSubscription) {
         this.flowSubscription = flowSubscription;
@@ -35,10 +41,28 @@ private HybridSubscription(Subscription reactiveSubscription) {
         this.reactiveSubscription = reactiveSubscription;
     }
 
+    /**
+     * Create new {@link HybridSubscription}
+     * from {@link io.helidon.common.reactive.Flow.Processor}.
+     *
+     * @param subscription {@link io.helidon.common.reactive.Flow.Subscription} to wrap
+     * @return {@link HybridSubscription}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static HybridSubscription from(Flow.Subscription subscription) {
         return new HybridSubscription(subscription);
     }
 
+    /**
+     * Create new {@link HybridSubscription}
+     * from {@link io.helidon.common.reactive.Flow.Subscription}.
+     *
+     * @param subscription {@link io.helidon.common.reactive.Flow.Subscription} to wrap
+     * @return {@link HybridSubscription}
+     * compatible with {@link org.reactivestreams Reactive Streams}
+     * and {@link io.helidon.common.reactive Helidon reactive streams}
+     */
     public static HybridSubscription from(Subscription subscription) {
         return new HybridSubscription(subscription);
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/package-info.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/package-info.java
new file mode 100644
index 00000000000..e4b3613ebe6
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * Hybrid variants of publishers/processors/subscribers usable in both apis
+ * {@link io.helidon.common.reactive Helidon reactive streams}
+ * and {@link org.reactivestreams Reactive Streams}.
+ */
+package io.helidon.microprofile.reactive.hybrid;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/package-info.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/package-info.java
new file mode 100644
index 00000000000..301c0f7aa49
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * Support for MicroProfile Reactive Streams Operators in Helidon MP.
+ */
+package io.helidon.microprofile.reactive;
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
index a2bf04a6454..c8d614918d6 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
@@ -50,6 +50,5 @@ public void request(long n) {
     @Override
     public void cancel() {
         closed.set(true);
-        subscriber.onComplete();
     }
 }

From e7b7015bf147a331747b0e7499317fb67feecd2c Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 20 Nov 2019 14:06:43 +0100
Subject: [PATCH 19/66] Check-style fixes for MP Reactive Messaging

Signed-off-by: Daniel Kec 
---
 .../messaging/MessagingCdiExtension.java      |  26 +-
 .../messaging/MessagingStreamException.java   |  33 +++
 .../messaging/NoConnectorFoundException.java  |  35 +++
 .../NotConnectableChannelException.java       |  59 +++++
 .../messaging/channel/AbstractChannel.java    | 222 ------------------
 .../messaging/channel/AbstractMethod.java     |  87 +++++++
 .../messaging/channel/ChannelRouter.java      | 133 +++++++----
 .../messaging/channel/IncomingMethod.java     |  87 ++++---
 .../InternalProcessor.java                    |  30 +--
 .../InternalPublisher.java                    |  21 +-
 .../InternalSubscriber.java                   |  23 +-
 .../messaging/{ => channel}/MessageUtils.java |  73 ++++--
 .../channel/MethodSignatureType.java          | 174 ++++++++++++++
 .../messaging/channel/OutgoingMethod.java     |  76 +++---
 .../messaging/channel/ProcessorMethod.java    | 101 ++++----
 .../{reactive => channel}/ProxyProcessor.java |  30 ++-
 .../messaging/channel/UniversalChannel.java   |  82 ++++---
 .../UnwrapProcessor.java                      |  17 +-
 .../messaging/channel/package-info.java       |  22 ++
 .../{ => connector}/AdHocConfigBuilder.java   |  22 +-
 .../connector/ConfigurableConnector.java      |  14 +-
 .../connector/IncomingConnector.java          |  29 ++-
 .../connector/OutgoingConnector.java          |  32 ++-
 .../connector/PublishingConnector.java        |   3 +-
 .../connector/SubscribingConnector.java       |   3 +-
 .../messaging/connector/package-info.java     |  22 ++
 .../microprofile/messaging/package-info.java  |  21 ++
 .../messaging/AbstractCDITest.java            |  10 +-
 .../{ => channel}/MessageUtilsTest.java       |   5 +-
 .../UnwrapProcessorTest.java                  |  23 +-
 .../AdHocConfigBuilderTest.java               |   8 +-
 microprofile/tests/tck/tck-messaging/pom.xml  |   2 +-
 32 files changed, 950 insertions(+), 575 deletions(-)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingStreamException.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NoConnectorFoundException.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NotConnectableChannelException.java
 delete mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive => channel}/InternalProcessor.java (83%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive => channel}/InternalPublisher.java (85%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive => channel}/InternalSubscriber.java (85%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ => channel}/MessageUtils.java (70%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive => channel}/ProxyProcessor.java (82%)
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{reactive => channel}/UnwrapProcessor.java (85%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/package-info.java
 rename microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/{ => connector}/AdHocConfigBuilder.java (79%)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/package-info.java
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/package-info.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{ => channel}/MessageUtilsTest.java (96%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{reactive => channel}/UnwrapProcessorTest.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{ => connector}/AdHocConfigBuilderTest.java (95%)

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
index 1d9fb7469ba..03b34ac60b7 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingCdiExtension.java
@@ -16,10 +16,7 @@
 
 package io.helidon.microprofile.messaging;
 
-import io.helidon.microprofile.messaging.channel.ChannelRouter;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.messaging.spi.Connector;
+import java.util.logging.Logger;
 
 import javax.enterprise.event.Observes;
 import javax.enterprise.inject.spi.AfterDeploymentValidation;
@@ -29,32 +26,37 @@
 import javax.enterprise.inject.spi.ProcessManagedBean;
 import javax.enterprise.inject.spi.WithAnnotations;
 
-import java.util.logging.Logger;
+import io.helidon.microprofile.messaging.channel.ChannelRouter;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.messaging.spi.Connector;
 
 /**
- * Extension with partial implementation of MicroProfile Reactive Messaging Specification
+ * MicroProfile Reactive Messaging CDI Extension.
  */
 public class MessagingCdiExtension implements Extension {
     private static final Logger LOGGER = Logger.getLogger(MessagingCdiExtension.class.getName());
 
     private ChannelRouter channelRouter = new ChannelRouter();
 
-    private void registerChannelMethods(@Observes @WithAnnotations({Incoming.class, Outgoing.class}) ProcessAnnotatedType pat) {
+    private void registerChannelMethods(
+            @Observes
+            @WithAnnotations({Incoming.class, Outgoing.class}) ProcessAnnotatedType pat) {
         // Lookup channel methods
-        pat.getAnnotatedType().getMethods().forEach(m -> channelRouter.addMethod(m));
+        pat.getAnnotatedType().getMethods().forEach(m -> channelRouter.registerMethod(m));
     }
 
-    public void onProcessBean(@Observes ProcessManagedBean event) {
+    private void onProcessBean(@Observes ProcessManagedBean event) {
         // Lookup connectors
         if (null != event.getAnnotatedBeanClass().getAnnotation(Connector.class)) {
-            channelRouter.addConnectorFactory(event.getBean());
+            channelRouter.registerConnectorFactory(event.getBean());
         }
         // Gather bean references
-        //TODO: Multiple bean references(not singleton)
         channelRouter.registerBeanReference(event.getBean());
     }
 
-    public void makeConnections(@Observes AfterDeploymentValidation event, BeanManager beanManager) {
+    private void makeConnections(@Observes AfterDeploymentValidation event, BeanManager beanManager) {
         LOGGER.info("Final connect");
         // Subscribe subscribers and publish publishers
         channelRouter.connect(beanManager);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingStreamException.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingStreamException.java
new file mode 100644
index 00000000000..efec7334fcf
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessagingStreamException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+/**
+ * Wrapper for all exceptions raised during stream passage.
+ */
+public class MessagingStreamException extends RuntimeException {
+
+    /**
+     * Create new {@link MessagingStreamException}.
+     *
+     * @param cause wrapped exception
+     */
+    public MessagingStreamException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NoConnectorFoundException.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NoConnectorFoundException.java
new file mode 100644
index 00000000000..ec1f91320d8
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NoConnectorFoundException.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+/**
+ * Raised when no connector of given name has been found.
+ */
+public class NoConnectorFoundException extends DeploymentException {
+
+    /**
+     * Create new {@link NoConnectorFoundException}.
+     *
+     * @param connectorName name of the connector
+     */
+    public NoConnectorFoundException(String connectorName) {
+        super(String.format("No connector %s found!", connectorName));
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NotConnectableChannelException.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NotConnectableChannelException.java
new file mode 100644
index 00000000000..0b046a6393f
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/NotConnectableChannelException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+/**
+ * Raised when channel hasn't candidate method or connector from both sides.
+ */
+public class NotConnectableChannelException extends DeploymentException {
+
+    /**
+     * Create new {@link NotConnectableChannelException}.
+     *
+     * @param channelName name of un-connectable channel
+     * @param type        incoming or outgoing {@link NotConnectableChannelException.Type}
+     */
+    public NotConnectableChannelException(String channelName, Type type) {
+        super(composeMessage(channelName, type));
+    }
+
+    private static String composeMessage(String channelName, Type type) {
+        return String.format("No %s method or connector for channel %s found!", type, channelName);
+    }
+
+    /**
+     * Incoming or outgoing method/connector.
+     */
+    public enum Type {
+        /**
+         * Incoming method or connector.
+         */
+        INCOMING,
+        /**
+         * Outgoing method or connector.
+         */
+        OUTGOING;
+
+        @Override
+        public String toString() {
+            return name().toLowerCase();
+        }
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
deleted file mode 100644
index bf40f2c4eb8..00000000000
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractChannel.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.messaging.channel;
-
-import io.helidon.config.Config;
-
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.lang.reflect.Method;
-
-public abstract class AbstractChannel {
-
-    protected String incomingChannelName;
-    protected String outgoingChannelName;
-
-    protected Bean bean;
-    private ChannelRouter router;
-    protected Method method;
-    protected Object beanInstance;
-    protected BeanManager beanManager;
-    protected Config config;
-    protected Type type;
-    public boolean connected = false;
-
-
-    public AbstractChannel(Method method, ChannelRouter router) {
-        this.router = router;
-        this.method = method;
-    }
-
-    abstract void validate();
-
-    public void init(BeanManager beanManager, Config config) {
-        this.beanInstance = getBeanInstance(bean, beanManager);
-        this.beanManager = beanManager;
-        this.config = config;
-    }
-
-    public Method getMethod() {
-        return method;
-    }
-
-    public Object getBeanInstance() {
-        return beanInstance;
-    }
-
-    public void setDeclaringBean(Bean bean) {
-        this.bean = bean;
-    }
-
-    public Class getDeclaringType() {
-        return method.getDeclaringClass();
-    }
-
-    public String getIncomingChannelName() {
-        return incomingChannelName;
-    }
-
-    public String getOutgoingChannelName() {
-        return outgoingChannelName;
-    }
-
-    public Type getType() {
-        return type;
-    }
-
-    public void setType(Type type) {
-        this.type = type;
-    }
-
-    public static Object getBeanInstance(Bean bean, BeanManager beanManager) {
-        javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope());
-        Object instance = context.get(bean);
-        if (instance == null) {
-            CreationalContext creationalContext = beanManager.createCreationalContext(bean);
-            instance = beanManager.getReference(bean, bean.getBeanClass(), creationalContext);
-        }
-        if (instance == null) {
-            throw new DeploymentException("Instance of bean " + bean.getName() + " not found");
-        }
-        return instance;
-    }
-
-    public ChannelRouter getRouter() {
-        return router;
-    }
-
-    public enum Type {
-        /**
-         * Invoke at: assembly time
-         * 
Processor<Message<I>, Message<O>> method();

-         * 
Processor<I, O> method();

-         */
-        PROCESSOR_VOID_2_PROCESSOR(true),
-        /**
-         * Invoke at: Assembly time -
-         * 
ProcessorBuilder<Message<I>, Message<O>> method();

-         * 

-         */
-        PROCESSOR_VOID_2_PROCESSOR_BUILDER(true),
-        /**
-         * Invoke at: assembly time
-         * 
Publisher<Message<O>> method(Message<I> msg);

-         * 
Publisher<O> method(I payload);

-         */
-        PROCESSOR_PUBLISHER_2_PUBLISHER(true),
-        /**
-         * Invoke at: assembly time
-         * 
PublisherBuilder<O> method(PublisherBuilder<I> pub);

-         */
-        PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true),
-        /**
-         * Invoke at: every incoming
-         * 
Publisher<Message<O>> method(Message<I>msg);

-         * 
Publisher<O> method(I payload);

-         */
-        PROCESSOR_MSG_2_PUBLISHER(false),
-        /**
-         * Invoke at: every incoming
-         * 
Message<O> method(Message<I> msg)

-         * 
O method(I payload)

-         */
-        PROCESSOR_MSG_2_MSG(false),
-        /**
-         * Invoke at: every incoming
-         * 
CompletionStage<Message<O>> method(Message<I> msg)

-         * 
CompletionStage<O> method(I payload)

-         */
-        PROCESSOR_MSG_2_COMPL_STAGE(false),
-
-
-        /**
-         * Invoke at: assembly time
-         * 
Subscriber<Message<I>> method()

-         * 
Subscriber<I> method()

-         */
-        INCOMING_VOID_2_SUBSCRIBER(true),
-        /**
-         * Invoke at: assembly time
-         * 
SubscriberBuilder<Message<I>> method()

-         * 
SubscriberBuilder<I> method()

-         */
-        INCOMING_VOID_2_SUBSCRIBER_BUILDER(true),
-        /**
-         * Invoke at: every incoming
-         * 
void method(I payload)

-         */
-        INCOMING_MSG_2_VOID(false),
-        /**
-         * Invoke at: every incoming
-         * 
CompletionStage<?> method(Message<I>msg)

-         * 
CompletionStage<?> method(I payload)

-         */
-        INCOMING_MSG_2_COMPLETION_STAGE(false),
-
-        /**
-         * Invoke at: assembly time
-         * 
Publisher<Message<U>> method()

-         * 
Publisher<U> method()

-         */
-        OUTGOING_VOID_2_PUBLISHER(true),
-
-        /**
-         * Invoke at: assembly time
-         * 
PublisherBuilder<Message<U>> method()

-         * 
PublisherBuilder<U> method()

-         */
-        OUTGOING_VOID_2_PUBLISHER_BUILDER(true),
-
-        /**
-         * Invoke at: Each request made by subscriber
-         * 
Message<U> method()

-         * 
U method()

-         * 

-         * Produces an infinite stream of Message associated with the
-         * channel channel. The result is a CompletionStage. The method should not be
-         * called by the reactive messaging implementation until the CompletionStage
-         * returned previously is completed.
-         */
-        OUTGOING_VOID_2_MSG(false),
-
-        /**
-         * Invoke at: Each request made by subscriber
-         * 
CompletionStage<Message<U>> method()

-         * 
CompletionStage<U> method()

-         * 

-         * Produces an infinite stream of Message associated with the
-         * channel channel. The result is a CompletionStage. The method should not be
-         * called by the reactive messaging implementation until the CompletionStage
-         * returned previously is completed.
-         */
-        OUTGOING_VOID_2_COMPLETION_STAGE(false);
-
-        private boolean invokeAtAssembly;
-
-        Type(boolean invokeAtAssembly) {
-            this.invokeAtAssembly = invokeAtAssembly;
-        }
-
-        public boolean isInvokeAtAssembly() {
-            return invokeAtAssembly;
-        }
-    }
-}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
new file mode 100644
index 00000000000..d1387f9b8b1
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.Method;
+
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+
+import io.helidon.config.Config;
+
+abstract class AbstractMethod {
+
+    private String incomingChannelName;
+    private String outgoingChannelName;
+
+    private  Bean bean;
+    private Method method;
+    private Object beanInstance;
+    private MethodSignatureType type;
+
+
+    AbstractMethod(Method method) {
+        this.method = method;
+    }
+
+    abstract void validate();
+
+    public void init(BeanManager beanManager, Config config) {
+        this.beanInstance = ChannelRouter.lookup(bean, beanManager);
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    Object getBeanInstance() {
+        return beanInstance;
+    }
+
+    void setDeclaringBean(Bean bean) {
+        this.bean = bean;
+    }
+
+    Class getDeclaringType() {
+        return method.getDeclaringClass();
+    }
+
+    String getIncomingChannelName() {
+        return incomingChannelName;
+    }
+
+    String getOutgoingChannelName() {
+        return outgoingChannelName;
+    }
+
+    void setIncomingChannelName(String incomingChannelName) {
+        this.incomingChannelName = incomingChannelName;
+    }
+
+    void setOutgoingChannelName(String outgoingChannelName) {
+        this.outgoingChannelName = outgoingChannelName;
+    }
+
+    public MethodSignatureType getType() {
+        return type;
+    }
+
+    public void setType(MethodSignatureType type) {
+        this.type = type;
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
index c573db09408..55d1faecd81 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
@@ -17,10 +17,23 @@
 
 package io.helidon.microprofile.messaging.channel;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+
 import io.helidon.config.Config;
 import io.helidon.microprofile.config.MpConfig;
 import io.helidon.microprofile.messaging.connector.IncomingConnector;
 import io.helidon.microprofile.messaging.connector.OutgoingConnector;
+
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -28,22 +41,13 @@
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
 
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
+/**
+ * Orchestrator for all found channels, methods and connectors.
+ */
 public class ChannelRouter {
     private Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig();
 
-    private List connectableBeanMethods = new ArrayList<>();
+    private List connectableBeanMethods = new ArrayList<>();
 
     private Map channelMap = new HashMap<>();
     private Map incomingConnectorMap = new HashMap<>();
@@ -53,12 +57,24 @@ public class ChannelRouter {
     private List> outgoingConnectorFactoryList = new ArrayList<>();
     private BeanManager beanManager;
 
+    /**
+     * Register bean reference with at least one annotated messaging method method.
+     *
+     * @param bean {@link javax.enterprise.inject.spi.Bean} with messaging methods reference
+     * @see org.eclipse.microprofile.reactive.messaging.Incoming
+     * @see org.eclipse.microprofile.reactive.messaging.Outgoing
+     */
     public void registerBeanReference(Bean bean) {
         connectableBeanMethods.stream()
                 .filter(m -> m.getDeclaringType() == bean.getBeanClass())
                 .forEach(m -> m.setDeclaringBean(bean));
     }
 
+    /**
+     * Connect all discovered channel graphs.
+     *
+     * @param beanManager {@link javax.enterprise.inject.spi.BeanManager} for looking-up bean instances of discovered methods
+     */
     public void connect(BeanManager beanManager) {
         this.beanManager = beanManager;
         //Needs to be initialized before connecting,
@@ -67,11 +83,58 @@ public void connect(BeanManager beanManager) {
         outgoingConnectorFactoryList.forEach(this::addIncomingConnector);
         connectableBeanMethods.forEach(m -> m.init(beanManager, config));
 
-
         channelMap.values().forEach(UniversalChannel::findConnectors);
         channelMap.values().stream().filter(UniversalChannel::isLastInChain).forEach(UniversalChannel::connect);
     }
 
+    /**
+     * Register messaging method.
+     *
+     * @param m {@link javax.enterprise.inject.spi.AnnotatedMethod}
+     *          with {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming}
+     *          or {@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotation
+     */
+    public void registerMethod(AnnotatedMethod m) {
+        if (m.isAnnotationPresent(Incoming.class) && m.isAnnotationPresent(Outgoing.class)) {
+            this.addProcessorMethod(m);
+        } else if (m.isAnnotationPresent(Incoming.class)) {
+            this.addIncomingMethod(m);
+        } else if (m.isAnnotationPresent(Outgoing.class)) {
+            this.addOutgoingMethod(m);
+        }
+    }
+
+    /**
+     * Register connector bean, can be recognized as a bean implementing
+     * {@link org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory}
+     * or {@link org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory}
+     * or both with annotation {@link org.eclipse.microprofile.reactive.messaging.spi.Connector}.
+     *
+     * @param bean connector bean
+     */
+    public void registerConnectorFactory(Bean bean) {
+        Class beanType = bean.getBeanClass();
+        Connector annotation = beanType.getAnnotation(Connector.class);
+        if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
+            incomingConnectorFactoryList.add(bean);
+        }
+        if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
+            outgoingConnectorFactoryList.add(bean);
+        }
+    }
+
+    public Config getConfig() {
+        return config;
+    }
+
+    Optional getIncomingConnector(String connectorName) {
+        return Optional.ofNullable(incomingConnectorMap.get(connectorName));
+    }
+
+    Optional getOutgoingConnector(String connectorName) {
+        return Optional.ofNullable(outgoingConnectorMap.get(connectorName));
+    }
+
     private void addIncomingConnector(Bean bean) {
         OutgoingConnectorFactory outgoingConnectorFactory = lookup(bean, beanManager);
         String connectorName = bean.getBeanClass().getAnnotation(Connector.class).value();
@@ -87,7 +150,7 @@ private void addOutgoingConnector(Bean bean) {
     }
 
     private void addIncomingMethod(AnnotatedMethod m) {
-        IncomingMethod incomingMethod = new IncomingMethod(m, this);
+        IncomingMethod incomingMethod = new IncomingMethod(m);
         incomingMethod.validate();
 
         String channelName = incomingMethod.getIncomingChannelName();
@@ -99,7 +162,7 @@ private void addIncomingMethod(AnnotatedMethod m) {
     }
 
     private void addOutgoingMethod(AnnotatedMethod m) {
-        OutgoingMethod outgoingMethod = new OutgoingMethod(m, this);
+        OutgoingMethod outgoingMethod = new OutgoingMethod(m);
         outgoingMethod.validate();
 
         String channelName = outgoingMethod.getOutgoingChannelName();
@@ -111,7 +174,7 @@ private void addOutgoingMethod(AnnotatedMethod m) {
     }
 
     private void addProcessorMethod(AnnotatedMethod m) {
-        ProcessorMethod channelMethod = new ProcessorMethod(m, this);
+        ProcessorMethod channelMethod = new ProcessorMethod(m);
         channelMethod.validate();
 
         String incomingChannelName = channelMethod.getIncomingChannelName();
@@ -126,39 +189,6 @@ private void addProcessorMethod(AnnotatedMethod m) {
         connectableBeanMethods.add(channelMethod);
     }
 
-    public void addMethod(AnnotatedMethod m) {
-        if (m.isAnnotationPresent(Incoming.class) && m.isAnnotationPresent(Outgoing.class)) {
-            this.addProcessorMethod(m);
-        } else if (m.isAnnotationPresent(Incoming.class)) {
-            this.addIncomingMethod(m);
-        } else if (m.isAnnotationPresent(Outgoing.class)) {
-            this.addOutgoingMethod(m);
-        }
-    }
-
-    public void addConnectorFactory(Bean bean) {
-        Class beanType = bean.getBeanClass();
-        Connector annotation = beanType.getAnnotation(Connector.class);
-        if (IncomingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
-            incomingConnectorFactoryList.add(bean);
-        }
-        if (OutgoingConnectorFactory.class.isAssignableFrom(beanType) && null != annotation) {
-            outgoingConnectorFactoryList.add(bean);
-        }
-    }
-
-    public Optional getIncomingConnector(String connectorName) {
-        return Optional.ofNullable(incomingConnectorMap.get(connectorName));
-    }
-
-    public Optional getOutgoingConnector(String connectorName) {
-        return Optional.ofNullable(outgoingConnectorMap.get(connectorName));
-    }
-
-    public Config getConfig() {
-        return config;
-    }
-
     private UniversalChannel getOrCreateChannel(String channelName) {
         UniversalChannel universalChannel = channelMap.get(channelName);
         if (universalChannel == null) {
@@ -168,7 +198,8 @@ private UniversalChannel getOrCreateChannel(String channelName) {
         return universalChannel;
     }
 
-    public static  T lookup(Bean bean, BeanManager beanManager) {
+    @SuppressWarnings("unchecked")
+    static  T lookup(Bean bean, BeanManager beanManager) {
         javax.enterprise.context.spi.Context context = beanManager.getContext(bean.getScope());
         Object instance = context.get(bean);
         if (instance == null) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index fde3f2d34bf..85cb8c832a4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -17,66 +17,75 @@
 
 package io.helidon.microprofile.messaging.channel;
 
-import io.helidon.config.Config;
-import io.helidon.microprofile.messaging.reactive.InternalSubscriber;
-import io.helidon.microprofile.messaging.reactive.UnwrapProcessor;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.reactivestreams.Subscriber;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
+import java.util.logging.Logger;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.lang.reflect.InvocationTargetException;
-import java.util.Objects;
-import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
+import io.helidon.config.Config;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Subscriber;
 
 /**
- * Subscriber with reference to {@link org.eclipse.microprofile.reactive.messaging.Incoming @Incoming}
- * /{@link org.eclipse.microprofile.reactive.messaging.Outgoing @Outgoing} annotated method
+ * Subscriber method with reference to processor method.
+ * 
Example:
+ * 
{@code
+ *     @Incoming("channel-name")
+ *     public void exampleIncomingMethod(String msg) {
+ *         ...
+ *     }
+ * }

  */
-public class IncomingMethod extends AbstractChannel {
+class IncomingMethod extends AbstractMethod {
 
     private static final Logger LOGGER = Logger.getLogger(IncomingMethod.class.getName());
 
     private Subscriber subscriber;
 
-    public IncomingMethod(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getJavaMember(), router);
-        super.incomingChannelName = method.getAnnotation(Incoming.class).value();
+    IncomingMethod(AnnotatedMethod method) {
+        super(method.getJavaMember());
+        super.setIncomingChannelName(method.getAnnotation(Incoming.class).value());
         resolveSignatureType();
     }
 
     void validate() {
-        if (incomingChannelName == null || incomingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Incoming on method "
-                    + method.toString());
+        if (getIncomingChannelName() == null || getIncomingChannelName().trim().isEmpty()) {
+            throw new DeploymentException(String
+                    .format("Missing channel name in annotation @Incoming on method %s", getMethod().toString()));
         }
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
-        if (type.isInvokeAtAssembly()) {
+        if (getType().isInvokeAtAssembly()) {
             try {
-                switch (type) {
+                switch (getType()) {
                     case INCOMING_VOID_2_SUBSCRIBER:
-                        subscriber = UnwrapProcessor.of(this.method, (Subscriber) method.invoke(beanInstance));
+                        subscriber = UnwrapProcessor.of(this.getMethod(), (Subscriber) getMethod()
+                                .invoke(getBeanInstance()));
                         break;
                     case INCOMING_VOID_2_SUBSCRIBER_BUILDER:
-                        subscriber = UnwrapProcessor.of(this.method, ((SubscriberBuilder) method.invoke(beanInstance)).build());
+                        subscriber = UnwrapProcessor.of(this.getMethod(),
+                                ((SubscriberBuilder) getMethod().invoke(getBeanInstance())).build());
                         break;
                     default:
-                        throw new UnsupportedOperationException("Not implemented signature " + type);
+                        throw new UnsupportedOperationException(String
+                                .format("Not implemented signature %s", getType()));
                 }
             } catch (IllegalAccessException | InvocationTargetException e) {
                 throw new RuntimeException(e);
             }
         } else {
             // Invoke on each message subscriber
-            subscriber = new InternalSubscriber(method, beanInstance);
+            subscriber = new InternalSubscriber(getMethod(), getBeanInstance());
         }
     }
 
@@ -85,36 +94,38 @@ public Subscriber getSubscriber() {
     }
 
     protected void resolveSignatureType() {
-        Class returnType = this.method.getReturnType();
+        Class returnType = this.getMethod().getReturnType();
         Class parameterType;
-        if (this.method.getParameterTypes().length == 1) {
-            parameterType = this.method.getParameterTypes()[0];
-        } else if (this.method.getParameterTypes().length == 0) {
+        if (this.getMethod().getParameterTypes().length == 1) {
+            parameterType = this.getMethod().getParameterTypes()[0];
+        } else if (this.getMethod().getParameterTypes().length == 0) {
             parameterType = Void.TYPE;
         } else {
-            throw new DeploymentException("Unsupported parameters on incoming method " + method);
+            throw new DeploymentException(String
+                    .format("Unsupported parameters on incoming method %s", getMethod()));
         }
 
         if (Void.TYPE.equals(parameterType)) {
             if (Subscriber.class.equals(returnType)) {
-                this.type = Type.INCOMING_VOID_2_SUBSCRIBER;
+                setType(MethodSignatureType.INCOMING_VOID_2_SUBSCRIBER);
             } else if (SubscriberBuilder.class.equals(returnType)) {
-                this.type = Type.INCOMING_VOID_2_SUBSCRIBER_BUILDER;
+                setType(MethodSignatureType.INCOMING_VOID_2_SUBSCRIBER_BUILDER);
             }
         } else {
             if (CompletionStage.class.equals(returnType)) {
-                this.type = Type.INCOMING_MSG_2_COMPLETION_STAGE;
+                setType(MethodSignatureType.INCOMING_MSG_2_COMPLETION_STAGE);
             } else if (Void.TYPE.equals(returnType)) {
-                this.type = Type.INCOMING_MSG_2_VOID;
+                setType(MethodSignatureType.INCOMING_MSG_2_VOID);
             } else {
-                //TODO: Remove when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
+                // Remove when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
                 // see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
-                this.type = Type.INCOMING_MSG_2_VOID;
+                setType(MethodSignatureType.INCOMING_MSG_2_VOID);
             }
         }
 
-        if (Objects.isNull(type)) {
-            throw new DeploymentException("Unsupported incoming method signature " + method);
+        if (Objects.isNull(getType())) {
+            throw new DeploymentException(String
+                    .format("Unsupported incoming method signature %s", getMethod()));
         }
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
similarity index 83%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
index 9514203aa54..9cd065cb77f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
@@ -15,10 +15,12 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.concurrent.ExecutionException;
 
-import io.helidon.microprofile.messaging.MessageUtils;
-import io.helidon.microprofile.messaging.channel.ProcessorMethod;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
@@ -27,27 +29,25 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.concurrent.ExecutionException;
-
 /**
- * Process every item in stream by method ex:
+ * Processor calling underlined messaging method for every received item.
+ * 

+ * Example:
  * 
{@code
- *      @Incoming("inner-processor")
- *      @Outgoing("inner-consumer")
+ *      @Incoming("channel-one")
+ *      @Outgoing("channel-two")
  *      public String process2(String msg) {
  *          return msg.toLowerCase();
  *      }
  * }

  */
-public class InternalProcessor implements Processor {
+class InternalProcessor implements Processor {
 
 
     private ProcessorMethod processorMethod;
     private Subscriber subscriber;
 
-    public InternalProcessor(ProcessorMethod processorMethod) {
+    InternalProcessor(ProcessorMethod processorMethod) {
         this.processorMethod = processorMethod;
     }
 
@@ -66,11 +66,11 @@ public void onSubscribe(Subscription s) {
     public void onNext(Object incomingValue) {
         try {
             Method method = processorMethod.getMethod();
-            //TODO: Has to be always one param in the processor, validate and propagate better
+            //Params size is already validated by ProcessorMethod
             Class paramType = method.getParameterTypes()[0];
             Object processedValue = method.invoke(processorMethod.getBeanInstance(),
                     MessageUtils.unwrap(incomingValue, paramType));
-            //TODO: Extract as some sensible util
+            //Method returns publisher, time for flattening its PROCESSOR_MSG_2_PUBLISHER or *_BUILDER
             if (processedValue instanceof Publisher || processedValue instanceof PublisherBuilder) {
                 //Flatten, we are sure its invoke on every request method now
                 PublisherBuilder publisherBuilder = null;
@@ -94,7 +94,7 @@ public void onNext(Object incomingValue) {
         }
     }
 
-    protected Object wrapValue(Object value) throws ExecutionException, InterruptedException {
+    private Object wrapValue(Object value) throws ExecutionException, InterruptedException {
         return MessageUtils.unwrap(value, Message.class);
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalPublisher.java
similarity index 85%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalPublisher.java
index 241e76d9153..5c780b9bae9 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalPublisher.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalPublisher.java
@@ -15,11 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
-
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
+package io.helidon.microprofile.messaging.channel;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -27,14 +23,21 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class InternalPublisher implements Publisher, Subscription {
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/**
+ * Publisher calling underlined messaging method for every requested item.
+ */
+class InternalPublisher implements Publisher, Subscription {
 
     private Method method;
     private Object beanInstance;
     private Subscriber subscriber;
     private AtomicBoolean closed = new AtomicBoolean(false);
 
-    public InternalPublisher(Method method, Object beanInstance) {
+    InternalPublisher(Method method, Object beanInstance) {
         this.method = method;
         this.beanInstance = beanInstance;
     }
@@ -48,10 +51,8 @@ public void subscribe(Subscriber s) {
     @Override
     public void request(long n) {
         try {
-            for (long i = 0; i < n
-                    && !closed.get(); i++) {
+            for (long i = 0; i < n && !closed.get(); i++) {
                 Object result = method.invoke(beanInstance);
-                //TODO: Completion stage blocking in the spec seems useless
                 if (result instanceof CompletionStage) {
                     CompletionStage completionStage = (CompletionStage) result;
                     subscriber.onNext(completionStage.toCompletableFuture().get());
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
similarity index 85%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
index 96c0204c3a5..223ea789827 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
@@ -15,18 +15,22 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.Method;
+import java.util.UUID;
 
 import io.helidon.common.context.Context;
 import io.helidon.common.context.Contexts;
-import io.helidon.microprofile.messaging.MessageUtils;
+import io.helidon.microprofile.messaging.MessagingStreamException;
+
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.lang.reflect.Method;
-import java.util.UUID;
-
-public class InternalSubscriber implements Subscriber {
+/**
+ * Publisher calling underlined messaging method for every received.
+ */
+class InternalSubscriber implements Subscriber {
 
     private Subscription subscription;
     private Long chunkSize = 5L;
@@ -34,7 +38,7 @@ public class InternalSubscriber implements Subscriber {
     private Method method;
     private Object beanInstance;
 
-    public InternalSubscriber(Method method, Object beanInstance) {
+    InternalSubscriber(Method method, Object beanInstance) {
         this.method = method;
         this.beanInstance = beanInstance;
     }
@@ -61,15 +65,14 @@ public void onNext(Object message) {
             incrementAndCheckChunkPosition();
         } catch (Exception e) {
             //Notify publisher to stop sending
-            // TODO: Maybe should not notify to stop sending, check the spec
             subscription.cancel();
-            throw new RuntimeException(e);
+            throw new MessagingStreamException(e);
         }
     }
 
     @Override
     public void onError(Throwable t) {
-        throw new RuntimeException(t);
+        throw new MessagingStreamException(t);
     }
 
     @Override
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
similarity index 70%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
index 44605790797..1bd082ca62d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
@@ -15,7 +15,16 @@
  *
  */
 
-package io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.security.InvalidParameterException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+import javax.enterprise.inject.spi.DeploymentException;
 
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
@@ -25,19 +34,29 @@
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import javax.enterprise.inject.spi.DeploymentException;
+class MessageUtils {
 
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.security.InvalidParameterException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-
-public class MessageUtils {
+    private MessageUtils() {
+    }
 
-    public static Object unwrap(Object value, Class type) throws ExecutionException, InterruptedException {
-        //TODO: Stream-line case by case
+    /**
+     * Unwrap values to expected types.
+     * 

+     * Examples:
+     * 
{@code
+     * Message>>
+     * Message>
+     * CompletableFuture>
+     * Message
+     * }

+     *
+     * @param value value for unwrap
+     * @param type  expected type
+     * @return unwrapped value
+     * @throws ExecutionException   can happen when unwrapping completable
+     * @throws InterruptedException can happen when unwrapping completable
+     */
+    static Object unwrap(Object value, Class type) throws ExecutionException, InterruptedException {
         if (type.equals(Message.class)) {
             if (value instanceof Message) {
                 return value;
@@ -57,7 +76,8 @@ public static Object unwrap(Object value, Class type) throws ExecutionExcepti
         }
     }
 
-    public static Object unwrapCompletableFuture(Object o, Class expectedType) throws ExecutionException, InterruptedException {
+    private static Object unwrapCompletableFuture(Object o, Class expectedType)
+            throws ExecutionException, InterruptedException {
         if (CompletableFuture.class.isInstance(o) && !CompletableFuture.class.isAssignableFrom(expectedType)) {
             //Recursion for Message>>
             return unwrap(((CompletableFuture) o).get(), expectedType);
@@ -65,19 +85,34 @@ public static Object unwrapCompletableFuture(Object o, Class expectedType) th
         return o;
     }
 
-    public static Object unwrap(Object o, Method method) throws ExecutionException, InterruptedException {
-        if (isTypeMessage(method)) {
-            return unwrap(o, Message.class);
+    /**
+     * Same as {@link io.helidon.microprofile.messaging.channel.MessageUtils#unwrap(java.lang.Object, java.lang.Class)}.
+     * But extracts expected type from method reflexively.
+     *
+     * @param value  to unwrap
+     * @param method to extract expected type from
+     * @return unwrapped value
+     * @throws ExecutionException   can happen when unwrapping completable
+     * @throws InterruptedException can happen when unwrapping completable
+     */
+    static Object unwrap(Object value, Method method) throws ExecutionException, InterruptedException {
+        if (isMessageType(method)) {
+            return unwrap(value, Message.class);
         }
-        return unwrap(o, getFirstGenericType(method));
+        return unwrap(value, getFirstGenericType(method));
     }
 
-    public static boolean isTypeMessage(Method method) {
+    /**
+     * Check if expected type is {@link org.eclipse.microprofile.reactive.messaging.Message}.
+     *
+     * @param method {@link java.lang.reflect.Method} to check
+     * @return true is expected type of method is {@link org.eclipse.microprofile.reactive.messaging.Message}
+     */
+    static boolean isMessageType(Method method) {
         Type returnType = method.getGenericReturnType();
         ParameterizedType parameterizedType = (ParameterizedType) returnType;
         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
 
-        //TODO: Use AbstractChannel.Type enum instead
         if (SubscriberBuilder.class.equals(method.getReturnType())) {
             if (actualTypeArguments.length != 2) {
                 throw new DeploymentException("Invalid method return type " + method);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
new file mode 100644
index 00000000000..75e893d03d1
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+/**
+ * Supported method signatures as described in the MicroProfile Reactive Messaging Specification.
+ */
+public enum MethodSignatureType {
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
Processor<Message<I>, Message<O>> method();

+     * 
Processor<I, O> method();

+     */
+    PROCESSOR_VOID_2_PROCESSOR(true),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: Assembly time -
+     * 
ProcessorBuilder<Message<I>, Message<O>> method();

+     * 

+     */
+    PROCESSOR_VOID_2_PROCESSOR_BUILDER(true),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
Publisher<Message<O>> method(Message<I> msg);

+     * 
Publisher<O> method(I payload);

+     */
+    PROCESSOR_PUBLISHER_2_PUBLISHER(true),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
PublisherBuilder<O> method(PublisherBuilder<I> pub);

+     */
+    PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: every incoming
+     * 
Publisher<Message<O>> method(Message<I>msg);

+     * 
Publisher<O> method(I payload);

+     */
+    PROCESSOR_MSG_2_PUBLISHER(false),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: every incoming
+     * 
Message<O> method(Message<I> msg)

+     * 
O method(I payload)

+     */
+    PROCESSOR_MSG_2_MSG(false),
+    /**
+     * Processor method signature type.
+     * 

+     * Invoke at: every incoming
+     * 
CompletionStage<Message<O>> method(Message<I> msg)

+     * 
CompletionStage<O> method(I payload)

+     */
+    PROCESSOR_MSG_2_COMPL_STAGE(false),
+
+
+    /**
+     * Subscriber method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
Subscriber<Message<I>> method()

+     * 
Subscriber<I> method()

+     */
+    INCOMING_VOID_2_SUBSCRIBER(true),
+    /**
+     * Subscriber method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
SubscriberBuilder<Message<I>> method()

+     * 
SubscriberBuilder<I> method()

+     */
+    INCOMING_VOID_2_SUBSCRIBER_BUILDER(true),
+    /**
+     * Subscriber method signature type.
+     * 

+     * Invoke at: every incoming
+     * 
void method(I payload)

+     */
+    INCOMING_MSG_2_VOID(false),
+    /**
+     * Subscriber method signature type.
+     * 

+     * Invoke at: every incoming
+     * 
CompletionStage<?> method(Message<I>msg)

+     * 
CompletionStage<?> method(I payload)

+     */
+    INCOMING_MSG_2_COMPLETION_STAGE(false),
+
+    /**
+     * Publisher method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
Publisher<Message<U>> method()

+     * 
Publisher<U> method()

+     */
+    OUTGOING_VOID_2_PUBLISHER(true),
+
+    /**
+     * Publisher method signature type.
+     * 

+     * Invoke at: assembly time
+     * 
PublisherBuilder<Message<U>> method()

+     * 
PublisherBuilder<U> method()

+     */
+    OUTGOING_VOID_2_PUBLISHER_BUILDER(true),
+
+    /**
+     * Publisher method signature type.
+     * 

+     * Invoke at: Each request made by subscriber
+     * 
Message<U> method()

+     * 
U method()

+     * 

+     * Produces an infinite stream of Message associated with the
+     * channel channel. The result is a CompletionStage. The method should not be
+     * called by the reactive messaging implementation until the CompletionStage
+     * returned previously is completed.
+     */
+    OUTGOING_VOID_2_MSG(false),
+
+    /**
+     * Publisher method signature type.
+     * 

+     * Invoke at: Each request made by subscriber
+     * 
CompletionStage<Message<U>> method()

+     * 
CompletionStage<U> method()

+     * 

+     * Produces an infinite stream of Message associated with the
+     * channel channel. The result is a CompletionStage. The method should not be
+     * called by the reactive messaging implementation until the CompletionStage
+     * returned previously is completed.
+     */
+    OUTGOING_VOID_2_COMPLETION_STAGE(false);
+
+    private boolean invokeAtAssembly;
+
+    MethodSignatureType(boolean invokeAtAssembly) {
+        this.invokeAtAssembly = invokeAtAssembly;
+    }
+
+    /**
+     * Method signatures which should be invoked at assembly(those registering publishers/processors/subscribers) are marked with true,
+     * to distinguish them from those which should be invoked for every item in the stream.
+     *
+     * @return {@code true} if should be invoked at assembly
+     */
+    public boolean isInvokeAtAssembly() {
+        return invokeAtAssembly;
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
index ca055ceae1d..51c02319a98 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -17,65 +17,63 @@
 
 package io.helidon.microprofile.messaging.channel;
 
-import io.helidon.config.Config;
-import io.helidon.microprofile.messaging.reactive.InternalPublisher;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.reactivestreams.Publisher;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.lang.reflect.InvocationTargetException;
-import java.util.Objects;
-import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
+import io.helidon.config.Config;
 
-public class OutgoingMethod extends AbstractChannel {
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.reactivestreams.Publisher;
 
-    private static final Logger LOGGER = Logger.getLogger(OutgoingMethod.class.getName());
+class OutgoingMethod extends AbstractMethod {
 
     private Publisher publisher;
 
-    public OutgoingMethod(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getJavaMember(), router);
-        super.outgoingChannelName = method.getAnnotation(Outgoing.class).value();
+    OutgoingMethod(AnnotatedMethod method) {
+        super(method.getJavaMember());
+        super.setOutgoingChannelName(method.getAnnotation(Outgoing.class).value());
         resolveSignatureType();
     }
 
     @Override
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
-        if (type.isInvokeAtAssembly()) {
+        if (getType().isInvokeAtAssembly()) {
             try {
-                switch (type) {
+                switch (getType()) {
                     case OUTGOING_VOID_2_PUBLISHER:
-                        publisher = (Publisher) method.invoke(beanInstance);
+                        publisher = (Publisher) getMethod().invoke(getBeanInstance());
                         break;
                     case OUTGOING_VOID_2_PUBLISHER_BUILDER:
-                        publisher = ((PublisherBuilder) method.invoke(beanInstance)).buildRs();
+                        publisher = ((PublisherBuilder) getMethod().invoke(getBeanInstance())).buildRs();
                         break;
                     default:
-                        throw new UnsupportedOperationException("Not implemented signature " + type);
+                        throw new UnsupportedOperationException(String
+                                .format("Not implemented signature %s", getType()));
                 }
             } catch (IllegalAccessException | InvocationTargetException e) {
                 throw new RuntimeException(e);
             }
         } else {
             // Invoke on each request publisher
-            publisher = new InternalPublisher(method, beanInstance);
+            publisher = new InternalPublisher(getMethod(), getBeanInstance());
         }
     }
 
-    public void validate() {
-        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Outgoing, method: "
-                    + method.toString());
+    void validate() {
+        if (getOutgoingChannelName() == null || getOutgoingChannelName().trim().isEmpty()) {
+            throw new DeploymentException(String
+                    .format("Missing channel name in annotation @Outgoing, method: %s", getMethod()));
         }
-        if (method.getReturnType().equals(Void.TYPE)) {
-            throw new DeploymentException("Method annotated as @Outgoing channel cannot have return type void, method: "
-                    + method.toString());
+        if (getMethod().getReturnType().equals(Void.TYPE)) {
+            throw new DeploymentException(String
+                    .format("Method annotated as @Outgoing channel cannot have return type void, method: %s", getMethod()));
         }
     }
 
@@ -83,26 +81,28 @@ public Publisher getPublisher() {
         return publisher;
     }
 
-    protected void resolveSignatureType() {
-        Class returnType = this.method.getReturnType();
-        if (this.method.getParameterTypes().length != 0) {
-            throw new DeploymentException("Unsupported parameters on outgoing method " + method);
+    private void resolveSignatureType() {
+        Class returnType = this.getMethod().getReturnType();
+        if (this.getMethod().getParameterTypes().length != 0) {
+            throw new DeploymentException(String
+                    .format("Unsupported parameters on outgoing method %s", getMethod()));
         }
 
         if (Void.class.isAssignableFrom(returnType)) {
-            type = null;
+            setType(null);
         } else if (Publisher.class.isAssignableFrom(returnType)) {
-            this.type = Type.OUTGOING_VOID_2_PUBLISHER;
+            setType(MethodSignatureType.OUTGOING_VOID_2_PUBLISHER);
         } else if (PublisherBuilder.class.isAssignableFrom(returnType)) {
-            this.type = Type.OUTGOING_VOID_2_PUBLISHER_BUILDER;
+            setType(MethodSignatureType.OUTGOING_VOID_2_PUBLISHER_BUILDER);
         } else if (CompletionStage.class.isAssignableFrom(returnType)) {
-            this.type = Type.OUTGOING_VOID_2_COMPLETION_STAGE;
+            setType(MethodSignatureType.OUTGOING_VOID_2_COMPLETION_STAGE);
         } else {
-            this.type = Type.OUTGOING_VOID_2_MSG;
+            setType(MethodSignatureType.OUTGOING_VOID_2_MSG);
         }
 
-        if (Objects.isNull(type)) {
-            throw new DeploymentException("Unsupported outgoing method signature " + method);
+        if (Objects.isNull(getType())) {
+            throw new DeploymentException(String
+                    .format("Unsupported outgoing method signature %s", getMethod()));
         }
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index 5ad2651eca3..40cf20a829d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -17,9 +17,15 @@
 
 package io.helidon.microprofile.messaging.channel;
 
+import java.lang.reflect.Method;
+import java.util.concurrent.CompletionStage;
+
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.DeploymentException;
+
 import io.helidon.config.Config;
-import io.helidon.microprofile.messaging.reactive.InternalProcessor;
-import io.helidon.microprofile.messaging.reactive.ProxyProcessor;
+
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
@@ -27,34 +33,22 @@
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 
-import javax.enterprise.inject.spi.AnnotatedMethod;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
-
-public class ProcessorMethod extends AbstractChannel {
-
-    private static final Logger LOGGER = Logger.getLogger(ProcessorMethod.class.getName());
+class ProcessorMethod extends AbstractMethod {
 
     private Processor processor;
-    private UniversalChannel incomingChannel;
     private UniversalChannel outgoingChannel;
 
-    public ProcessorMethod(AnnotatedMethod method, ChannelRouter router) {
-        super(method.getJavaMember(), router);
-        super.incomingChannelName =
-                method.getAnnotation(Incoming.class).value();
-        super.outgoingChannelName =
-                method.getAnnotation(Outgoing.class).value();
+    ProcessorMethod(AnnotatedMethod method) {
+        super(method.getJavaMember());
+        super.setIncomingChannelName(method.getAnnotation(Incoming.class).value());
+        super.setOutgoingChannelName(method.getAnnotation(Outgoing.class).value());
         resolveSignatureType();
     }
 
     @Override
     public void init(BeanManager beanManager, Config config) {
         super.init(beanManager, config);
-        if (type.isInvokeAtAssembly()) {
+        if (getType().isInvokeAtAssembly()) {
             processor = new ProxyProcessor(this);
         } else {
             // Create brand new subscriber
@@ -64,18 +58,18 @@ public void init(BeanManager beanManager, Config config) {
 
     @Override
     public void validate() {
-        if (incomingChannelName == null || incomingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Incoming on method "
-                    + method.toString());
+        if (getIncomingChannelName() == null || getIncomingChannelName().trim().isEmpty()) {
+            throw new DeploymentException(String
+                    .format("Missing channel name in annotation @Incoming on method %s", getMethod()));
         }
-        if (outgoingChannelName == null || outgoingChannelName.trim().isEmpty()) {
-            throw new DeploymentException("Missing channel name in annotation @Outgoing on method "
-                    + method.toString());
+        if (getOutgoingChannelName() == null || getOutgoingChannelName().trim().isEmpty()) {
+            throw new DeploymentException(String
+                    .format("Missing channel name in annotation @Outgoing on method %s", getMethod()));
         }
-        if (this.method.getParameterTypes().length > 1) {
+        if (this.getMethod().getParameterTypes().length > 1) {
             throw new DeploymentException("Bad processor method signature, "
                     + "wrong number of parameters, only one or none allowed."
-                    + method.toString());
+                    + getMethod());
         }
     }
 
@@ -83,49 +77,52 @@ public Processor getProcessor() {
         return processor;
     }
 
-    public UniversalChannel getIncomingChannel() {
-        return incomingChannel;
-    }
-
-    public void setIncomingChannel(UniversalChannel incomingChannel) {
-        this.incomingChannel = incomingChannel;
-    }
-
-    public UniversalChannel getOutgoingChannel() {
+    UniversalChannel getOutgoingChannel() {
         return outgoingChannel;
     }
 
-    public void setOutgoingChannel(UniversalChannel outgoingChannel) {
+    void setOutgoingChannel(UniversalChannel outgoingChannel) {
         this.outgoingChannel = outgoingChannel;
     }
 
     private void resolveSignatureType() {
-        Class returnType = this.method.getReturnType();
-            Class parameterType = Void.TYPE;
-        if (this.method.getParameterTypes().length == 1) {
-            parameterType = this.method.getParameterTypes()[0];
-        } else if (this.method.getParameterTypes().length > 1) {
-            throw new DeploymentException("Bad processor method signature " + method);
+        Method method = getMethod();
+        Class returnType = method.getReturnType();
+        Class parameterType = Void.TYPE;
+
+        if (method.getParameterTypes().length == 1) {
+            parameterType = method.getParameterTypes()[0];
+
+        } else if (method.getParameterTypes().length > 1) {
+            throw new DeploymentException(String
+                    .format("Bad processor method signature %s", method));
         }
         if (Void.TYPE.equals(parameterType)) {
             if (Processor.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_VOID_2_PROCESSOR;
+                setType(MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR);
+
             } else if (ProcessorBuilder.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER;
+                setType(MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR_BUILDER);
+
             } else {
-                throw new DeploymentException("Bad processor method signature " + method);
+                throw new DeploymentException(String
+                        .format("Bad processor method signature %s", method));
             }
         } else if (Publisher.class.equals(parameterType) && Publisher.class.equals(returnType)) {
-            this.type = Type.PROCESSOR_PUBLISHER_2_PUBLISHER;
+            setType(MethodSignatureType.PROCESSOR_PUBLISHER_2_PUBLISHER);
+
         } else if (PublisherBuilder.class.equals(parameterType) && PublisherBuilder.class.equals(returnType)) {
-            this.type = Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER;
+            setType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER);
+
         } else {
             if (Publisher.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_MSG_2_PUBLISHER;
+                setType(MethodSignatureType.PROCESSOR_MSG_2_PUBLISHER);
+
             } else if (CompletionStage.class.equals(returnType)) {
-                this.type = Type.PROCESSOR_MSG_2_COMPL_STAGE;
+                setType(MethodSignatureType.PROCESSOR_MSG_2_COMPL_STAGE);
+
             } else {
-                this.type = Type.PROCESSOR_MSG_2_MSG;
+                setType(MethodSignatureType.PROCESSOR_MSG_2_MSG);
             }
         }
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
similarity index 82%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
index 171f50d5973..77f64270f38 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
@@ -15,11 +15,13 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.ExecutionException;
+
+import javax.enterprise.inject.spi.DeploymentException;
 
-import io.helidon.microprofile.messaging.MessageUtils;
-import io.helidon.microprofile.messaging.channel.AbstractChannel;
-import io.helidon.microprofile.messaging.channel.ProcessorMethod;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
@@ -28,13 +30,8 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import javax.enterprise.inject.spi.DeploymentException;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.concurrent.ExecutionException;
-
 /**
- * Passes publisher to processor method ex:
+ * Passes publisher to processor method. ex:
  * 
{@code
  *     @Incoming("inner-processor")
  *     @Outgoing("inner-processor-2")
@@ -43,7 +40,7 @@
  *     }
  * }

  */
-public class ProxyProcessor implements Processor {
+class ProxyProcessor implements Processor {
 
     private final ProcessorMethod processorMethod;
     private final Publisher publisher;
@@ -52,27 +49,27 @@ public class ProxyProcessor implements Processor {
     private boolean subscribed = false;
 
     @SuppressWarnings("unchecked")
-    public ProxyProcessor(ProcessorMethod processorMethod) {
+    ProxyProcessor(ProcessorMethod processorMethod) {
         this.processorMethod = processorMethod;
         try {
-            if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER) {
+            if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER) {
                 PublisherBuilder paramPublisherBuilder = ReactiveStreams.fromPublisher(this);
                 publisher = ((PublisherBuilder) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance(), paramPublisherBuilder)).buildRs();
 
-            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_PUBLISHER_2_PUBLISHER) {
+            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PUBLISHER_2_PUBLISHER) {
                 publisher = ((Publisher) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance(), this));
 
-            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_VOID_2_PROCESSOR_BUILDER) {
+            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR_BUILDER) {
                 processor = ((ProcessorBuilder) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance())).buildRs();
                 publisher = processor;
 
-            } else if (processorMethod.getType() == AbstractChannel.Type.PROCESSOR_VOID_2_PROCESSOR) {
+            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR) {
                 processor = ((Processor) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance()));
@@ -88,6 +85,7 @@ public ProxyProcessor(ProcessorMethod processorMethod) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void subscribe(Subscriber s) {
         if (processor != null) {
             // Backed by real  processor
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
index 3b0fcb95cbb..aea8ceebc3d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UniversalChannel.java
@@ -17,20 +17,23 @@
 
 package io.helidon.microprofile.messaging.channel;
 
+import java.util.Optional;
+import java.util.logging.Logger;
+
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
+import io.helidon.microprofile.messaging.NoConnectorFoundException;
+import io.helidon.microprofile.messaging.NotConnectableChannelException;
 import io.helidon.microprofile.messaging.connector.IncomingConnector;
 import io.helidon.microprofile.messaging.connector.OutgoingConnector;
-import io.helidon.microprofile.messaging.reactive.ProxyProcessor;
-import org.reactivestreams.Processor;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import javax.enterprise.inject.spi.DeploymentException;
+class UniversalChannel {
 
-import java.util.Optional;
+    private static final Logger LOGGER = Logger.getLogger(UniversalChannel.class.getName());
 
-public class UniversalChannel {
     private String name;
     private IncomingConnector incomingConnector;
     private ProcessorMethod incomingProcessorMethod;
@@ -39,94 +42,103 @@ public class UniversalChannel {
     private OutgoingConnector outgoingConnector;
     private ProcessorMethod outgoingProcessorMethod;
     private Publisher publisher;
-    private Subscriber subscriber;
     private Config config;
     private ChannelRouter router;
     private Optional upstreamChannel = Optional.empty();
 
-    public UniversalChannel(ChannelRouter router) {
+    UniversalChannel(ChannelRouter router) {
         this.router = router;
         this.config = router.getConfig();
     }
 
-    public void setIncoming(IncomingMethod incomingMethod) {
+    void setIncoming(IncomingMethod incomingMethod) {
         this.name = incomingMethod.getIncomingChannelName();
         this.incomingMethod = incomingMethod;
     }
 
-    public void setIncoming(ProcessorMethod processorMethod) {
+    void setIncoming(ProcessorMethod processorMethod) {
         this.name = processorMethod.getIncomingChannelName();
         this.incomingProcessorMethod = processorMethod;
         this.incomingProcessorMethod.setOutgoingChannel(this);
     }
 
-    public void setOutgoing(ProcessorMethod processorMethod) {
+    void setOutgoing(ProcessorMethod processorMethod) {
         this.name = processorMethod.getOutgoingChannelName();
         this.outgoingProcessorMethod = processorMethod;
-        this.outgoingProcessorMethod.setIncomingChannel(this);
     }
 
-    public void setOutgoing(OutgoingMethod outgoingMethod) {
+    void setOutgoing(OutgoingMethod outgoingMethod) {
         this.name = outgoingMethod.getOutgoingChannelName();
         this.outgoingMethod = outgoingMethod;
     }
 
-    public String getName() {
-        return name;
-    }
+    @SuppressWarnings("unchecked")
+    void connect() {
+        StringBuilder connectMessage = new StringBuilder("Connecting channel ")
+                .append(name).append(" with outgoing method ");
 
-    public void connect() {
         if (outgoingMethod != null) {
             publisher = outgoingMethod.getPublisher();
-            System.out.print(outgoingMethod.method.getName() + " >> ");
+            connectMessage.append(outgoingMethod.getMethod().getName());
+
         } else if (outgoingProcessorMethod != null) {
             publisher = outgoingProcessorMethod.getProcessor();
             upstreamChannel = Optional.of(outgoingProcessorMethod.getOutgoingChannel());
-            System.out.print(outgoingProcessorMethod.method.getName() + " >> ");
-        } else if(outgoingConnector != null){
+            connectMessage.append(outgoingProcessorMethod.getMethod().getName());
+
+        } else if (outgoingConnector != null) {
             publisher = outgoingConnector.getPublisher(name);
-            System.out.print(outgoingConnector.getConnectorName() + " >> ");
+            connectMessage.append(outgoingConnector.getConnectorName());
         } else {
-            throw new DeploymentException("No outgoing channel " + name + " found!");
+            LOGGER.severe(connectMessage.append("and no outgoing method found!").toString());
+            throw new NotConnectableChannelException(name, NotConnectableChannelException.Type.OUTGOING);
         }
 
+        connectMessage.append(" and incoming method ");
+
+        Subscriber subscriber1;
         if (incomingMethod != null) {
-            subscriber = incomingMethod.getSubscriber();
-            System.out.println(name + " >> " + incomingMethod.method.getName());
-            publisher.subscribe(subscriber);
+            subscriber1 = incomingMethod.getSubscriber();
+            connectMessage.append(incomingMethod.getMethod().getName());
+            publisher.subscribe(subscriber1);
             //Continue connecting processor chain
             upstreamChannel.ifPresent(UniversalChannel::connect);
+
         } else if (incomingProcessorMethod != null) {
-            subscriber = incomingProcessorMethod.getProcessor();
-            System.out.println(name + " >> " + incomingProcessorMethod.method.getName());
-            publisher.subscribe(subscriber);
+            subscriber1 = incomingProcessorMethod.getProcessor();
+            connectMessage.append(incomingProcessorMethod.getMethod().getName());
+            publisher.subscribe(subscriber1);
             //Continue connecting processor chain
             upstreamChannel.ifPresent(UniversalChannel::connect);
+
         } else if (incomingConnector != null) {
-            Subscriber subscriber = incomingConnector.getSubscriber(name);
-            System.out.println(name + " >> " + incomingConnector.getConnectorName());
-            publisher.subscribe(subscriber);
+            subscriber1 = incomingConnector.getSubscriber(name);
+            connectMessage.append(incomingConnector.getConnectorName());
+            publisher.subscribe(subscriber1);
             //Continue connecting processor chain
             upstreamChannel.ifPresent(UniversalChannel::connect);
+
         } else {
-            throw new DeploymentException("No incoming channel " + name + " found!");
+            LOGGER.severe(connectMessage.append("and no incoming method found!").toString());
+            throw new NotConnectableChannelException(name, NotConnectableChannelException.Type.INCOMING);
         }
     }
 
-    public boolean isLastInChain() {
+    boolean isLastInChain() {
         return incomingProcessorMethod == null;
     }
 
-    public void findConnectors() {
+    void findConnectors() {
+        //Looks suspicious but incoming connector configured for outgoing channel is ok
         ConfigValue incomingConnectorName = config.get("mp.messaging.outgoing").get(name).get("connector").asString();
         ConfigValue outgoingConnectorName = config.get("mp.messaging.incoming").get(name).get("connector").asString();
         if (incomingConnectorName.isPresent()) {
             incomingConnector = router.getIncomingConnector(incomingConnectorName.get())
-                    .orElseThrow(() -> new DeploymentException("No connector " + incomingConnectorName.get() + " found!"));
+                    .orElseThrow(() -> new NoConnectorFoundException(incomingConnectorName.get()));
         }
         if (outgoingConnectorName.isPresent()) {
             outgoingConnector = router.getOutgoingConnector(outgoingConnectorName.get())
-                    .orElseThrow(() -> new DeploymentException("No connector " + outgoingConnectorName.get() + " found!"));
+                    .orElseThrow(() -> new NoConnectorFoundException(outgoingConnectorName.get()));
         }
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UnwrapProcessor.java
similarity index 85%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UnwrapProcessor.java
index 930203fde1d..9855cdd9371 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/UnwrapProcessor.java
@@ -15,21 +15,20 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.channel;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.ExecutionException;
 
-import io.helidon.microprofile.messaging.MessageUtils;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.lang.reflect.Method;
-import java.util.concurrent.ExecutionException;
-
 /**
  * Unwrap Message payload if incoming method Publisher or Publisher builder
- * has generic return type different than Message
+ * has generic return type different than Message.
  */
-public class UnwrapProcessor implements Processor {
+class UnwrapProcessor implements Processor {
 
     private Method method;
     private Subscriber subscriber;
@@ -37,7 +36,7 @@ public class UnwrapProcessor implements Processor {
     UnwrapProcessor() {
     }
 
-    public static UnwrapProcessor of(Method method, Subscriber subscriber) {
+    static UnwrapProcessor of(Method method, Subscriber subscriber) {
         UnwrapProcessor unwrapProcessor = new UnwrapProcessor();
         unwrapProcessor.subscribe(subscriber);
         unwrapProcessor.setMethod(method);
@@ -78,7 +77,7 @@ public void onComplete() {
         subscriber.onComplete();
     }
 
-    public void setMethod(Method method) {
+    void setMethod(Method method) {
         this.method = method;
     }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/package-info.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/package-info.java
new file mode 100644
index 00000000000..82ba9d32549
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * MicroProfile Reactive Messaging channels and bean methods abstraction model
+ * orchestrated by {@link io.helidon.microprofile.messaging.channel.ChannelRouter}.
+ */
+package io.helidon.microprofile.messaging.channel;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
similarity index 79%
rename from microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java
rename to microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
index b15fb4d819e..433e6a08519 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/AdHocConfigBuilder.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,18 +12,22 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.connector;
+
+import java.util.Properties;
 
 import io.helidon.common.CollectionsHelper;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 import io.helidon.microprofile.config.MpConfig;
 
-import java.util.Properties;
-
-public class AdHocConfigBuilder {
+/**
+ *
+ */
+class AdHocConfigBuilder {
     private Config config;
     private Properties properties = new Properties();
 
@@ -31,21 +35,21 @@ private AdHocConfigBuilder(Config config) {
         this.config = config.detach();
     }
 
-    public static AdHocConfigBuilder from(Config config) {
+    static AdHocConfigBuilder from(Config config) {
         return new AdHocConfigBuilder(config);
     }
 
-    public AdHocConfigBuilder put(String key, String value) {
+    AdHocConfigBuilder put(String key, String value) {
         properties.setProperty(key, value);
         return this;
     }
 
-    public AdHocConfigBuilder putAll(Config configToPut) {
+    AdHocConfigBuilder putAll(Config configToPut) {
         properties.putAll(configToPut.detach().asMap().orElse(CollectionsHelper.mapOf()));
         return this;
     }
 
-    public org.eclipse.microprofile.config.Config build() {
+    org.eclipse.microprofile.config.Config build() {
         Config newConfig = Config.builder(ConfigSources.create(properties), ConfigSources.create(config))
                 .disableEnvironmentVariablesSource()
                 .disableSystemPropertiesSource()
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
index 139c80e1d68..f7329e82e8c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/ConfigurableConnector.java
@@ -17,14 +17,14 @@
 
 package io.helidon.microprofile.messaging.connector;
 
+import javax.enterprise.inject.spi.DeploymentException;
+
 import io.helidon.config.Config;
 import io.helidon.config.ConfigValue;
-import io.helidon.microprofile.messaging.AdHocConfigBuilder;
-import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
 
-import javax.enterprise.inject.spi.DeploymentException;
+import org.eclipse.microprofile.reactive.messaging.spi.ConnectorFactory;
 
-public interface ConfigurableConnector {
+interface ConfigurableConnector {
 
     String getConnectorName();
 
@@ -40,10 +40,12 @@ default org.eclipse.microprofile.config.Config getConnectorConfig(String channel
                 .asString();
 
         if (!connectorName.isPresent()) {
-            throw new DeploymentException("No connector configured for channel " + channelName);
+            throw new DeploymentException(String
+                    .format("No connector configured for channel %s", channelName));
         }
         if (!connectorName.get().equals(getConnectorName())) {
-            throw new DeploymentException("Connector name miss match for channel" + channelName);
+            throw new DeploymentException(String
+                    .format("Connector name miss match for channel%s", channelName));
         }
 
         Config connectorConfig = getRootConfig()
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
index 432f647dfe9..83966224f8e 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
@@ -17,26 +17,45 @@
 
 package io.helidon.microprofile.messaging.connector;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import io.helidon.config.Config;
 import io.helidon.microprofile.messaging.channel.ChannelRouter;
+
 import org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory;
 import org.reactivestreams.Subscriber;
 
-import java.util.HashMap;
-import java.util.Map;
-
+/**
+ * Connector as defined in configuration.
+ * 

+ * 
{@code
+ * mp.messaging.incoming.[channel-name].connector=[connector-name]
+ * ...
+ * mp.messaging.outgoing.[channel-name].connector=[connector-name]
+ * ...
+ * mp.messaging.connector.[connector-name].[attribute]=[value]
+ * ...
+ * }

+ */
 public class IncomingConnector implements SubscribingConnector {
 
     private final Config config;
     private String connectorName;
     private OutgoingConnectorFactory connectorFactory;
-    private ChannelRouter router;
     private Map subscriberMap = new HashMap<>();
 
+    /**
+     * Create new {@link IncomingConnector}.
+     *
+     * @param connectorName    {@code [connector-name]} as defined in config
+     * @param connectorFactory actual instance of connector bean found in cdi context
+     *                         with annotation {@link org.eclipse.microprofile.reactive.messaging.spi.Connector}
+     * @param router           {@link io.helidon.microprofile.messaging.channel.ChannelRouter} main orchestrator with root config
+     */
     public IncomingConnector(String connectorName, OutgoingConnectorFactory connectorFactory, ChannelRouter router) {
         this.connectorName = connectorName;
         this.connectorFactory = connectorFactory;
-        this.router = router;
         this.config = router.getConfig();
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
index ffa349177c6..29caec3a60f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
@@ -17,27 +17,46 @@
 
 package io.helidon.microprofile.messaging.connector;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import io.helidon.config.Config;
 import io.helidon.microprofile.messaging.channel.ChannelRouter;
+
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import java.util.HashMap;
-import java.util.Map;
-
+/**
+ * Connector as defined in configuration.
+ * 

+ * 
{@code
+ * mp.messaging.incoming.[channel-name].connector=[connector-name]
+ * ...
+ * mp.messaging.outgoing.[channel-name].connector=[connector-name]
+ * ...
+ * mp.messaging.connector.[connector-name].[attribute]=[value]
+ * ...
+ * }

+ */
 public class OutgoingConnector implements PublishingConnector {
 
     private final Config config;
     private String connectorName;
     private IncomingConnectorFactory connectorFactory;
-    private ChannelRouter router;
     private Map publisherMap = new HashMap<>();
 
+    /**
+     * Create new {@link OutgoingConnector}.
+     *
+     * @param connectorName    {@code [connector-name]} as defined in config
+     * @param connectorFactory actual instance of connector bean found in cdi context
+     *                         with annotation {@link org.eclipse.microprofile.reactive.messaging.spi.Connector}
+     * @param router           {@link io.helidon.microprofile.messaging.channel.ChannelRouter} main orchestrator with root config
+     */
     public OutgoingConnector(String connectorName, IncomingConnectorFactory connectorFactory, ChannelRouter router) {
         this.connectorName = connectorName;
         this.connectorFactory = connectorFactory;
-        this.router = router;
         this.config = router.getConfig();
     }
 
@@ -64,7 +83,8 @@ public Publisher getPublisher(String channelName) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void subscribe(String channelName, Subscriber subscriber) {
         getPublisher(channelName).subscribe(subscriber);
     }
-}
\ No newline at end of file
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
index 2661e8c9ea4..991b79857d5 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/PublishingConnector.java
@@ -18,10 +18,11 @@
 package io.helidon.microprofile.messaging.connector;
 
 import io.helidon.config.Config;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-public interface PublishingConnector extends ConfigurableConnector {
+interface PublishingConnector extends ConfigurableConnector {
 
     @Override
     default Config getChannelsConfig() {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
index b9e9ac12b74..dad6e3a8866 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/SubscribingConnector.java
@@ -18,9 +18,10 @@
 package io.helidon.microprofile.messaging.connector;
 
 import io.helidon.config.Config;
+
 import org.reactivestreams.Subscriber;
 
-public interface SubscribingConnector extends ConfigurableConnector {
+interface SubscribingConnector extends ConfigurableConnector {
 
     @Override
     default Config getChannelsConfig() {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/package-info.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/package-info.java
new file mode 100644
index 00000000000..7d7837deac0
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * MicroProfile Reactive Messaging connectors abstraction model orchestrated by
+ * {@link io.helidon.microprofile.messaging.channel.ChannelRouter}.
+ */
+package io.helidon.microprofile.messaging.connector;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/package-info.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/package-info.java
new file mode 100644
index 00000000000..a0ac1f76f72
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * MicroProfile Reactive Messaging implementation.
+ */
+package io.helidon.microprofile.messaging;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index 59ffb46be3d..90cb980714c 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -88,10 +88,9 @@ protected void cdiBeanClasses(Set> classes) {
 
     @BeforeEach
     public void setUp() {
-        Map p = new HashMap<>();
         Set> classes = new HashSet<>();
         cdiBeanClasses(classes);
-        p.putAll(cdiConfig());
+        Map p = new HashMap<>(cdiConfig());
         cdiContainer = startCdiContainer(p, classes);
     }
 
@@ -107,7 +106,7 @@ protected  void forEachBean(Class beanType, Annotation annotation, Consume
         cdiContainer.select(beanType, annotation).stream().forEach(consumer);
     }
 
-    public void assertAllReceived(CountableTestBean bean) {
+    protected void assertAllReceived(CountableTestBean bean) {
         try {
             assertTrue(bean.getTestLatch().await(2, TimeUnit.SECONDS)
                     , "All messages not delivered in time, number of unreceived messages: "
@@ -117,11 +116,11 @@ public void assertAllReceived(CountableTestBean bean) {
         }
     }
 
-    public static SeContainer startCdiContainer(Map p, Class... beanClasses) {
+    protected static SeContainer startCdiContainer(Map p, Class... beanClasses) {
         return startCdiContainer(p, new HashSet<>(Arrays.asList(beanClasses)));
     }
 
-    public static SeContainer startCdiContainer(Map p, Set> beanClasses) {
+    private static SeContainer startCdiContainer(Map p, Set> beanClasses) {
         Config config = Config.builder()
                 .sources(ConfigSources.create(p))
                 .build();
@@ -172,6 +171,7 @@ public Optional> getExpectedThrowable() {
                     .findFirst();
         }
 
+        @SuppressWarnings("unchecked")
         public List> getCountableBeanClasses() {
             return Arrays.stream(clazzes)
                     .filter(CountableTestBean.class::isAssignableFrom)
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
similarity index 96%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
index 5771d209599..03dc88298cb 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/MessageUtilsTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.channel;
 
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -25,6 +25,9 @@
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Stream;
 
+import io.helidon.microprofile.messaging.channel.MessageUtils;
+
+
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class MessageUtilsTest {
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/UnwrapProcessorTest.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/UnwrapProcessorTest.java
index 391a3f996ab..11e0dead413 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/reactive/UnwrapProcessorTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/UnwrapProcessorTest.java
@@ -15,23 +15,26 @@
  *
  */
 
-package io.helidon.microprofile.messaging.reactive;
+package io.helidon.microprofile.messaging.channel;
 
-import io.helidon.microprofile.messaging.MessageUtils;
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.reactivestreams.Subscriber;
 
 import java.lang.reflect.Method;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Stream;
 
+
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.reactivestreams.Subscriber;
+
 public class UnwrapProcessorTest {
 
     public SubscriberBuilder testMethodSubscriberBuilderString() {
@@ -62,10 +65,10 @@ void innerChannelBeanTest(Method method) throws ExecutionException, InterruptedE
         unwrapProcessor.setMethod(method);
         Object unwrappedValue = unwrapProcessor.unwrap(Message.of("test"));
         if (method.getName().endsWith("Message")) {
-            assertTrue(MessageUtils.isTypeMessage(method));
+            Assertions.assertTrue(MessageUtils.isMessageType(method));
             assertTrue(unwrappedValue instanceof Message);
         } else {
-            assertFalse(MessageUtils.isTypeMessage(method));
+            assertFalse(MessageUtils.isMessageType(method));
             assertFalse(unwrappedValue instanceof Message);
         }
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
similarity index 95%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
index a29d4d07af0..b19dc2092f1 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AdHocConfigBuilderTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,13 +12,15 @@
  * 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 io.helidon.microprofile.messaging;
+package io.helidon.microprofile.messaging.connector;
 
-import io.helidon.common.CollectionsHelper;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
+import io.helidon.microprofile.messaging.connector.AdHocConfigBuilder;
+
 import org.apache.kafka.common.serialization.LongSerializer;
 import org.junit.jupiter.api.Test;
 
diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml
index 8089563ec2a..3b34cd73705 100644
--- a/microprofile/tests/tck/tck-messaging/pom.xml
+++ b/microprofile/tests/tck/tck-messaging/pom.xml
@@ -23,7 +23,7 @@
     4.0.0
     
         io.helidon.microprofile.tests
-        tests-project
+        tck-project
         1.3.2-SNAPSHOT
     
     tck-messaging

From 11d6ecfb19e60770b3f7bb854ca842d0397aa4e4 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 20 Nov 2019 15:34:30 +0100
Subject: [PATCH 20/66] Spot-bugs fixes

Signed-off-by: Daniel Kec 
---
 .../messaging/channel/IncomingMethod.java     | 10 +++++-----
 .../messaging/channel/InternalSubscriber.java | 19 +++++--------------
 .../reactive/MultiStagesCollector.java        |  3 ++-
 ...ava => RedeemingCompletionSubscriber.java} | 12 ++++++------
 .../reactive/hybrid/HybridProcessor.java      |  8 +++++++-
 5 files changed, 25 insertions(+), 27 deletions(-)
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/{CompletionSubscriber.java => RedeemingCompletionSubscriber.java} (82%)

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 85cb8c832a4..748f8c34cb4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -114,12 +114,12 @@ protected void resolveSignatureType() {
         } else {
             if (CompletionStage.class.equals(returnType)) {
                 setType(MethodSignatureType.INCOMING_MSG_2_COMPLETION_STAGE);
-            } else if (Void.TYPE.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_MSG_2_VOID);
-            } else {
-                // Remove when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
-                // see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
+// Uncomment when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
+// see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
+            } else /*if (Void.TYPE.equals(returnType))*/ {
                 setType(MethodSignatureType.INCOMING_MSG_2_VOID);
+//            } else {
+//                throw new DeploymentException("Not supported method signature.");
             }
         }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
index 223ea789827..aadfb625b5c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
@@ -28,13 +28,11 @@
 import org.reactivestreams.Subscription;
 
 /**
- * Publisher calling underlined messaging method for every received.
+ * Publisher calling underlined messaging method for every received item.
  */
 class InternalSubscriber implements Subscriber {
 
     private Subscription subscription;
-    private Long chunkSize = 5L;
-    private Long chunkPosition = 0L;
     private Method method;
     private Object beanInstance;
 
@@ -46,8 +44,8 @@ class InternalSubscriber implements Subscriber {
     @Override
     public void onSubscribe(Subscription s) {
         subscription = s;
-        //First chunk request
-        subscription.request(chunkSize);
+        // request one by one
+        subscription.request(1);
     }
 
     @Override
@@ -59,10 +57,10 @@ public void onNext(Object message) {
             Context context = Context
                     .builder()
                     .parent(parentContext)
-                    .id(parentContext.id() + ":message-" + UUID.randomUUID().toString())
+                    .id(String.format("%s:message-%s", parentContext.id(), UUID.randomUUID().toString()))
                     .build();
             Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, MessageUtils.unwrap(message, paramType)));
-            incrementAndCheckChunkPosition();
+            subscription.request(1);
         } catch (Exception e) {
             //Notify publisher to stop sending
             subscription.cancel();
@@ -80,11 +78,4 @@ public void onComplete() {
 
     }
 
-    private void incrementAndCheckChunkPosition() {
-        chunkPosition++;
-        if (chunkPosition >= chunkSize) {
-            chunkPosition = 0L;
-            subscription.request(chunkSize);
-        }
-    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index e5569b8e3b2..3243372d418 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -127,7 +127,8 @@ public BiConsumer, Stage> accumulator() {
                 Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
                 Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
                 this.completionStage = new CompletableFuture<>();
-                CompletionSubscriber completionSubscriber = CompletionSubscriber.of(subscriber, completionStage);
+                RedeemingCompletionSubscriber completionSubscriber =
+                        RedeemingCompletionSubscriber.of(subscriber, completionStage);
                 // If producer was supplied
                 subscribeUpStream();
                 multi.subscribe(HybridSubscriber.from(completionSubscriber));
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
similarity index 82%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index eeb11ee2de3..c54fc99b095 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -30,24 +30,24 @@
  * @param  {@link java.util.concurrent.CompletionStage} payload type
  * @see microprofile-reactive-streams-operators #129
  */
-class CompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
+class RedeemingCompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
 
     private final Subscriber subscriber;
     private final CompletionStage completion;
 
     /**
-     * Create a {@link io.helidon.microprofile.reactive.CompletionSubscriber} by combining the given subscriber and completion stage.
+     * Create a {@link RedeemingCompletionSubscriber} by combining the given subscriber and completion stage.
      * The objects passed to this method should not be associated with more than one stream instance.
      *
      * @param subscriber subscriber to associate with completion stage
      * @param completion completion stage to associate with subscriber
-     * @return {@link io.helidon.microprofile.reactive.CompletionSubscriber}
+     * @return {@link RedeemingCompletionSubscriber}
      */
-    static  CompletionSubscriber of(Subscriber subscriber, CompletionStage completion) {
-        return new CompletionSubscriber<>(subscriber, completion);
+    static  RedeemingCompletionSubscriber of(Subscriber subscriber, CompletionStage completion) {
+        return new RedeemingCompletionSubscriber<>(subscriber, completion);
     }
 
-    private CompletionSubscriber(Subscriber subscriber, CompletionStage completion) {
+    private RedeemingCompletionSubscriber(Subscriber subscriber, CompletionStage completion) {
         this.subscriber = subscriber;
         this.completion = completion;
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
index 0658fc46c96..9e5620eaf47 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
@@ -93,7 +93,13 @@ public void subscribe(Subscriber s) {
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
-        this.onSubscribe(subscription);
+        if (reactiveProcessor != null) {
+            reactiveProcessor.onSubscribe(HybridSubscription.from(subscription));
+        } else if (flowProcessor != null) {
+            flowProcessor.onSubscribe(subscription);
+        } else {
+            throw new InvalidParameterException("Hybrid processor has no processor");
+        }
     }
 
     @Override

From 3ccfea070ca89e7a0d692fa924422a017924cf8b Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 21 Nov 2019 17:32:13 +0100
Subject: [PATCH 21/66] Method signatures decomposition to different ack types

Signed-off-by: Daniel Kec 
---
 .../messaging/channel/AbstractMethod.java     |  18 +-
 .../messaging/channel/IncomingMethod.java     |  19 +-
 .../channel/MethodSignatureType.java          | 251 ++++++++++++++++--
 .../messaging/channel/OutgoingMethod.java     |  16 +-
 .../messaging/channel/ProcessorMethod.java    |  12 +-
 .../messaging/channel/ProxyProcessor.java     |   4 +-
 .../messaging/AbstractCDITest.java            |   8 +
 .../messaging/CompletableTestBean.java        |  24 ++
 .../messaging/inner/InnerChannelTest.java     |  35 ++-
 .../inner/ack/ChainWithPayloadAckBean.java    |  60 +++++
 .../messaging/inner/ack/ManualAckBean.java    |  54 ++++
 11 files changed, 449 insertions(+), 52 deletions(-)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
index d1387f9b8b1..0e7b4b37296 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
@@ -24,15 +24,18 @@
 
 import io.helidon.config.Config;
 
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+
 abstract class AbstractMethod {
 
     private String incomingChannelName;
     private String outgoingChannelName;
 
-    private  Bean bean;
+    private Bean bean;
     private Method method;
     private Object beanInstance;
     private MethodSignatureType type;
+    private Acknowledgment.Strategy ackStrategy;
 
 
     AbstractMethod(Method method) {
@@ -41,8 +44,12 @@ abstract class AbstractMethod {
 
     abstract void validate();
 
+    abstract void resolveSignatureType();
+
     public void init(BeanManager beanManager, Config config) {
         this.beanInstance = ChannelRouter.lookup(bean, beanManager);
+        resolveSignatureType();
+        resolveAckStrategy();
     }
 
     public Method getMethod() {
@@ -84,4 +91,13 @@ public MethodSignatureType getType() {
     public void setType(MethodSignatureType type) {
         this.type = type;
     }
+
+    public Acknowledgment.Strategy getAckStrategy() {
+        return ackStrategy;
+    }
+
+    private void resolveAckStrategy() {
+        //Only default for now
+        ackStrategy = type.getDefaultAckType();
+    }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 748f8c34cb4..90d4f472cd7 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -20,7 +20,6 @@
 import java.lang.reflect.InvocationTargetException;
 import java.util.Objects;
 import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
@@ -44,14 +43,11 @@
  */
 class IncomingMethod extends AbstractMethod {
 
-    private static final Logger LOGGER = Logger.getLogger(IncomingMethod.class.getName());
-
     private Subscriber subscriber;
 
     IncomingMethod(AnnotatedMethod method) {
         super(method.getJavaMember());
         super.setIncomingChannelName(method.getAnnotation(Incoming.class).value());
-        resolveSignatureType();
     }
 
     void validate() {
@@ -68,11 +64,11 @@ public void init(BeanManager beanManager, Config config) {
         if (getType().isInvokeAtAssembly()) {
             try {
                 switch (getType()) {
-                    case INCOMING_VOID_2_SUBSCRIBER:
+                    case INCOMING_SUBSCRIBER_MSG_2_VOID:
                         subscriber = UnwrapProcessor.of(this.getMethod(), (Subscriber) getMethod()
                                 .invoke(getBeanInstance()));
                         break;
-                    case INCOMING_VOID_2_SUBSCRIBER_BUILDER:
+                    case INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID:
                         subscriber = UnwrapProcessor.of(this.getMethod(),
                                 ((SubscriberBuilder) getMethod().invoke(getBeanInstance())).build());
                         break;
@@ -81,7 +77,7 @@ public void init(BeanManager beanManager, Config config) {
                                 .format("Not implemented signature %s", getType()));
                 }
             } catch (IllegalAccessException | InvocationTargetException e) {
-                throw new RuntimeException(e);
+                throw new DeploymentException(e);
             }
         } else {
             // Invoke on each message subscriber
@@ -93,6 +89,7 @@ public Subscriber getSubscriber() {
         return subscriber;
     }
 
+    @Override
     protected void resolveSignatureType() {
         Class returnType = this.getMethod().getReturnType();
         Class parameterType;
@@ -107,17 +104,17 @@ protected void resolveSignatureType() {
 
         if (Void.TYPE.equals(parameterType)) {
             if (Subscriber.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_VOID_2_SUBSCRIBER);
+                setType(MethodSignatureType.INCOMING_SUBSCRIBER_MSG_2_VOID);
             } else if (SubscriberBuilder.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_VOID_2_SUBSCRIBER_BUILDER);
+                setType(MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID);
             }
         } else {
             if (CompletionStage.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_MSG_2_COMPLETION_STAGE);
+                setType(MethodSignatureType.INCOMING_COMPLETION_STAGE_2_MSG);
 // Uncomment when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
 // see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
             } else /*if (Void.TYPE.equals(returnType))*/ {
-                setType(MethodSignatureType.INCOMING_MSG_2_VOID);
+                setType(MethodSignatureType.INCOMING_VOID_2_PAYL);
 //            } else {
 //                throw new DeploymentException("Not supported method signature.");
             }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
index 75e893d03d1..70a82c26886 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
@@ -17,6 +17,12 @@
 
 package io.helidon.microprofile.messaging.channel;
 
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+
 /**
  * Supported method signatures as described in the MicroProfile Reactive Messaging Specification.
  */
@@ -26,56 +32,178 @@ public enum MethodSignatureType {
      * 

      * Invoke at: assembly time
      * 
Processor<Message<I>, Message<O>> method();

+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
+     */
+    PROCESSOR_PROCESSOR_MSG_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.MANUAL
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    Processor<I, O> method();
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_VOID_2_PROCESSOR(true),
+    PROCESSOR_PROCESSOR_PAYL_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: Assembly time -
      * 
    ProcessorBuilder<Message<I>, Message<O>> method();
    
-     * 
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
      */
-    PROCESSOR_VOID_2_PROCESSOR_BUILDER(true),
+    PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.MANUAL
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: Assembly time -
+     * 
    ProcessorBuilder<I, O> method();
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     */
+    PROCESSOR_PROCESSOR_BUILDER_PAYL_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: assembly time
      * 
    Publisher<Message<O>> method(Message<I> msg);
    
      * 
    Publisher<O> method(I payload);
    
+     * 
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_PUBLISHER_2_PUBLISHER(true),
+    PROCESSOR_PUBLISHER_2_PUBLISHER(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: assembly time
      * 
    PublisherBuilder<O> method(PublisherBuilder<I> pub);
    
+     * 
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true),
+    PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
      * 
    Publisher<Message<O>> method(Message<I>msg);
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     */
+    PROCESSOR_PUBLISHER_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    Publisher<O> method(I payload);
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     */
+    PROCESSOR_PUBLISHER_PAYL_2_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: every incoming
+     * 
    PublisherBuilder<Message<O>> method(Message<I>msg);
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      */
-    PROCESSOR_MSG_2_PUBLISHER(false),
+    PROCESSOR_PUBLISHER_BUILDER_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: every incoming
+     * 
    PublisherBuilder<O> method(<I> msg);
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     */
+    PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
      * 
    Message<O> method(Message<I> msg)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     */
+    PROCESSOR_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: every incoming
      * 
    O method(I payload)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_MSG_2_MSG(false),
+    PROCESSOR_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
      * 
    CompletionStage<Message<O>> method(Message<I> msg)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     */
+    PROCESSOR_COMPL_STAGE_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: every incoming
      * 
    CompletionStage<O> method(I payload)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_MSG_2_COMPL_STAGE(false),
+    PROCESSOR_COMPL_STAGE_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
 
 
     /**
@@ -83,32 +211,96 @@ public enum MethodSignatureType {
      * 
    
      * Invoke at: assembly time
      * 
    Subscriber<Message<I>> method()
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     */
+    INCOMING_SUBSCRIBER_MSG_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
+
+    /**
+     * Subscriber method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    Subscriber<I> method()
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      */
-    INCOMING_VOID_2_SUBSCRIBER(true),
+    INCOMING_SUBSCRIBER_PAYL_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
     /**
      * Subscriber method signature type.
      * 
    
      * Invoke at: assembly time
      * 
    SubscriberBuilder<Message<I>> method()
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     */
+    INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
+    /**
+     * Subscriber method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    SubscriberBuilder<I> method()
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      */
-    INCOMING_VOID_2_SUBSCRIBER_BUILDER(true),
+    INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
     /**
      * Subscriber method signature type.
      * 
    
      * Invoke at: every incoming
      * 
    void method(I payload)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      */
-    INCOMING_MSG_2_VOID(false),
+    INCOMING_VOID_2_PAYL(false, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
     /**
      * Subscriber method signature type.
      * 
    
      * Invoke at: every incoming
      * 
    CompletionStage<?> method(Message<I>msg)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     */
+    INCOMING_COMPLETION_STAGE_2_MSG(false, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
+    /**
+     * Subscriber method signature type.
+     * 
    
+     * Invoke at: every incoming
      * 
    CompletionStage<?> method(I payload)
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      */
-    INCOMING_MSG_2_COMPLETION_STAGE(false),
+    INCOMING_COMPLETION_STAGE_2_PAYL(false, Acknowledgment.Strategy.POST_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
+    ),
 
     /**
      * Publisher method signature type.
@@ -117,7 +309,7 @@ public enum MethodSignatureType {
      * 
    Publisher<Message<U>> method()
    
      * 
    Publisher<U> method()
    
      */
-    OUTGOING_VOID_2_PUBLISHER(true),
+    OUTGOING_PUBLISHER_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
@@ -126,7 +318,7 @@ public enum MethodSignatureType {
      * 
    PublisherBuilder<Message<U>> method()
    
      * 
    PublisherBuilder<U> method()
    
      */
-    OUTGOING_VOID_2_PUBLISHER_BUILDER(true),
+    OUTGOING_PUBLISHER_BUILDER_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
@@ -140,7 +332,7 @@ public enum MethodSignatureType {
      * called by the reactive messaging implementation until the CompletionStage
      * returned previously is completed.
      */
-    OUTGOING_VOID_2_MSG(false),
+    OUTGOING_MSG_2_VOID(false, null),
 
     /**
      * Publisher method signature type.
@@ -154,12 +346,18 @@ public enum MethodSignatureType {
      * called by the reactive messaging implementation until the CompletionStage
      * returned previously is completed.
      */
-    OUTGOING_VOID_2_COMPLETION_STAGE(false);
+    OUTGOING_COMPLETION_STAGE_2_VOID(false, null);
 
     private boolean invokeAtAssembly;
+    private Acknowledgment.Strategy defaultAckType;
+    private Set supportedAckStrategies;
 
-    MethodSignatureType(boolean invokeAtAssembly) {
+    MethodSignatureType(boolean invokeAtAssembly,
+                        Acknowledgment.Strategy defaultAckType,
+                        Acknowledgment.Strategy... supportedAckTypes) {
         this.invokeAtAssembly = invokeAtAssembly;
+        this.defaultAckType = defaultAckType;
+        this.supportedAckStrategies = new HashSet<>(Arrays.asList(supportedAckTypes));
     }
 
     /**
@@ -171,4 +369,23 @@ public enum MethodSignatureType {
     public boolean isInvokeAtAssembly() {
         return invokeAtAssembly;
     }
+
+    /**
+     * Return set of supported acknowledgment strategies.
+     *
+     * @return Set of {@link org.eclipse.microprofile.reactive.messaging.Acknowledgment.Strategy}
+     */
+    public Set getSupportedAckStrategies() {
+        return supportedAckStrategies;
+    }
+
+    /**
+     * Default {@link org.eclipse.microprofile.reactive.messaging.Acknowledgment.Strategy}
+     * if nothing was set by {@link org.eclipse.microprofile.reactive.messaging.Acknowledgment}.
+     *
+     * @return Default {@link org.eclipse.microprofile.reactive.messaging.Acknowledgment.Strategy}
+     */
+    public Acknowledgment.Strategy getDefaultAckType() {
+        return defaultAckType;
+    }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
index 51c02319a98..1b607080f5d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -38,7 +38,6 @@ class OutgoingMethod extends AbstractMethod {
     OutgoingMethod(AnnotatedMethod method) {
         super(method.getJavaMember());
         super.setOutgoingChannelName(method.getAnnotation(Outgoing.class).value());
-        resolveSignatureType();
     }
 
     @Override
@@ -47,10 +46,10 @@ public void init(BeanManager beanManager, Config config) {
         if (getType().isInvokeAtAssembly()) {
             try {
                 switch (getType()) {
-                    case OUTGOING_VOID_2_PUBLISHER:
+                    case OUTGOING_PUBLISHER_2_VOID:
                         publisher = (Publisher) getMethod().invoke(getBeanInstance());
                         break;
-                    case OUTGOING_VOID_2_PUBLISHER_BUILDER:
+                    case OUTGOING_PUBLISHER_BUILDER_2_VOID:
                         publisher = ((PublisherBuilder) getMethod().invoke(getBeanInstance())).buildRs();
                         break;
                     default:
@@ -81,7 +80,8 @@ public Publisher getPublisher() {
         return publisher;
     }
 
-    private void resolveSignatureType() {
+    @Override
+    protected void resolveSignatureType() {
         Class returnType = this.getMethod().getReturnType();
         if (this.getMethod().getParameterTypes().length != 0) {
             throw new DeploymentException(String
@@ -91,13 +91,13 @@ private void resolveSignatureType() {
         if (Void.class.isAssignableFrom(returnType)) {
             setType(null);
         } else if (Publisher.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_VOID_2_PUBLISHER);
+            setType(MethodSignatureType.OUTGOING_PUBLISHER_2_VOID);
         } else if (PublisherBuilder.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_VOID_2_PUBLISHER_BUILDER);
+            setType(MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_2_VOID);
         } else if (CompletionStage.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_VOID_2_COMPLETION_STAGE);
+            setType(MethodSignatureType.OUTGOING_COMPLETION_STAGE_2_VOID);
         } else {
-            setType(MethodSignatureType.OUTGOING_VOID_2_MSG);
+            setType(MethodSignatureType.OUTGOING_MSG_2_VOID);
         }
 
         if (Objects.isNull(getType())) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index 40cf20a829d..b6ca2441c0f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -42,7 +42,6 @@ class ProcessorMethod extends AbstractMethod {
         super(method.getJavaMember());
         super.setIncomingChannelName(method.getAnnotation(Incoming.class).value());
         super.setOutgoingChannelName(method.getAnnotation(Outgoing.class).value());
-        resolveSignatureType();
     }
 
     @Override
@@ -85,7 +84,8 @@ void setOutgoingChannel(UniversalChannel outgoingChannel) {
         this.outgoingChannel = outgoingChannel;
     }
 
-    private void resolveSignatureType() {
+    @Override
+    protected void resolveSignatureType() {
         Method method = getMethod();
         Class returnType = method.getReturnType();
         Class parameterType = Void.TYPE;
@@ -99,10 +99,10 @@ private void resolveSignatureType() {
         }
         if (Void.TYPE.equals(parameterType)) {
             if (Processor.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR);
+                setType(MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID);
 
             } else if (ProcessorBuilder.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR_BUILDER);
+                setType(MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID);
 
             } else {
                 throw new DeploymentException(String
@@ -116,10 +116,10 @@ private void resolveSignatureType() {
 
         } else {
             if (Publisher.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_MSG_2_PUBLISHER);
+                setType(MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_MSG);
 
             } else if (CompletionStage.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_MSG_2_COMPL_STAGE);
+                setType(MethodSignatureType.PROCESSOR_COMPL_STAGE_MSG_2_MSG);
 
             } else {
                 setType(MethodSignatureType.PROCESSOR_MSG_2_MSG);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
index 77f64270f38..ecb594402c4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
@@ -63,13 +63,13 @@ class ProxyProcessor implements Processor {
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance(), this));
 
-            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR_BUILDER) {
+            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID) {
                 processor = ((ProcessorBuilder) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance())).buildRs();
                 publisher = processor;
 
-            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_VOID_2_PROCESSOR) {
+            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID) {
                 processor = ((Processor) processorMethod
                         .getMethod()
                         .invoke(processorMethod.getBeanInstance()));
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index 90cb980714c..730499c45c4 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -178,5 +178,13 @@ public List> getCountableBeanClasses() {
                     .map(c -> (Class) c)
                     .collect(Collectors.toList());
         }
+
+        @SuppressWarnings("unchecked")
+        public List> getCompletableBeanClasses() {
+            return Arrays.stream(clazzes)
+                    .filter(CompletableTestBean.class::isAssignableFrom)
+                    .map(c -> (Class) c)
+                    .collect(Collectors.toList());
+        }
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java
new file mode 100644
index 00000000000..2b36ccd74a9
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging;
+
+import java.util.concurrent.CompletionStage;
+
+public interface CompletableTestBean {
+    CompletionStage getTestCompletion();
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index 95bf6c12180..ea6ec3ab4b5 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -17,18 +17,28 @@
 
 package io.helidon.microprofile.messaging.inner;
 
-import io.helidon.microprofile.messaging.AbstractCDITest;
-import io.helidon.microprofile.messaging.CountableTestBean;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import javax.enterprise.inject.spi.CDI;
-
 import java.util.Collections;
 import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
+import javax.enterprise.inject.spi.CDI;
+
+import io.helidon.microprofile.messaging.AbstractCDITest;
+import io.helidon.microprofile.messaging.CompletableTestBean;
+import io.helidon.microprofile.messaging.CountableTestBean;
+import io.helidon.microprofile.messaging.inner.ack.ManualAckBean;
+import io.helidon.microprofile.messaging.inner.ack.ChainWithPayloadAckBean;
+
+
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class InnerChannelTest extends AbstractCDITest {
 
@@ -71,6 +81,9 @@ static Stream testCaseSource() {
                 PublisherProcessorV3Bean.class,
                 PublisherProcessorV2Bean.class,
                 PublisherProcessorV1Bean.class,
+                //Ack tests
+//                ChainWithPayloadAckBean.class,
+//                ManualAckBean.class,
 
                 //Negative tests
                 NotConnectedIncommingChannelBean.class,
@@ -93,6 +106,14 @@ void innerChannelBeanTest(CdiTestCase testCase) {
                 // Wait till all messages are delivered
                 assertAllReceived(countableTestBean);
             });
+            testCase.getCompletableBeanClasses().forEach(c -> {
+                CompletableTestBean completableTestBean = CDI.current().select(c).get();
+                try {
+                    completableTestBean.getTestCompletion().toCompletableFuture().get(1, TimeUnit.SECONDS);
+                } catch (InterruptedException | TimeoutException | ExecutionException e) {
+                    fail(e);
+                }
+            });
         }
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java
new file mode 100644
index 00000000000..026ecbcec56
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.CompletableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ChainWithPayloadAckBean implements CompletableTestBean {
+
+    private CompletableFuture future = new CompletableFuture<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return MultiRS.just(Message.of("test-data", () -> future));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public String process(String msg) {
+        return msg.toUpperCase();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public void receiveMessage(Message msg) {
+        msg.ack().toCompletableFuture().complete(null);
+    }
+
+    @Override
+    public CompletionStage getTestCompletion() {
+        return future;
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java
new file mode 100644
index 00000000000..223eedd0a1a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.CompletableTestBean;
+import io.helidon.microprofile.reactive.MultiRS;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ManualAckBean implements CompletableTestBean {
+
+    private CompletableFuture future = new CompletableFuture<>();
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return MultiRS.just(Message.of("test-data", () -> future));
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public void receiveMessage(Message msg) {
+        msg.ack().toCompletableFuture().complete(null);
+    }
+
+    @Override
+    public CompletionStage getTestCompletion() {
+        return future;
+    }
+}

From c40bde70a1a2b37ca88964685b84be11f479a0bf Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 23 Nov 2019 00:45:06 +0100
Subject: [PATCH 22/66] Method signature resolving refactor

Signed-off-by: Daniel Kec 
---
 messaging/pom.xml                             |  36 +++
 .../messaging/channel/AbstractMethod.java     |   4 +-
 .../messaging/channel/IncomingMethod.java     |  43 +--
 .../messaging/channel/InternalSubscriber.java |   2 +-
 .../channel/MethodSignatureResolver.java      | 305 +++++++++++++++++
 .../channel/MethodSignatureType.java          |  93 +++++-
 .../messaging/channel/OutgoingMethod.java     |  34 +-
 .../messaging/channel/ProcessorMethod.java    |  49 ---
 .../messaging/channel/ProxyProcessor.java     |  55 ++--
 .../channel/MethodSignatureResolverTest.java  | 306 ++++++++++++++++++
 .../channel/SignatureTypeConsistencyTest.java |  48 +++
 .../messaging/kafka/KafkaConsumingBean.java   |  17 +-
 pom.xml                                       |   1 +
 13 files changed, 825 insertions(+), 168 deletions(-)
 create mode 100644 messaging/pom.xml
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolver.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/SignatureTypeConsistencyTest.java

diff --git a/messaging/pom.xml b/messaging/pom.xml
new file mode 100644
index 00000000000..ec2e7028898
--- /dev/null
+++ b/messaging/pom.xml
@@ -0,0 +1,36 @@
+
+
+
+
+    4.0.0
+    
+        io.helidon
+        helidon-project
+        1.3.2-SNAPSHOT
+    
+    pom
+    io.helidon.messaging
+    helidon-messaging-project
+    Helidon Messaging Project
+
+    
+        kafka
+    
+
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
index 0e7b4b37296..fb974b19434 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
@@ -44,11 +44,9 @@ abstract class AbstractMethod {
 
     abstract void validate();
 
-    abstract void resolveSignatureType();
-
     public void init(BeanManager beanManager, Config config) {
         this.beanInstance = ChannelRouter.lookup(bean, beanManager);
-        resolveSignatureType();
+        type = MethodSignatureResolver.create(method).resolve();
         resolveAckStrategy();
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 90d4f472cd7..2fdaed4690c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -18,8 +18,6 @@
 package io.helidon.microprofile.messaging.channel;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.Objects;
-import java.util.concurrent.CompletionStage;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
@@ -65,10 +63,14 @@ public void init(BeanManager beanManager, Config config) {
             try {
                 switch (getType()) {
                     case INCOMING_SUBSCRIBER_MSG_2_VOID:
+                        subscriber = (Subscriber) getMethod().invoke(getBeanInstance());
+                        break;
+                    case INCOMING_SUBSCRIBER_PAYL_2_VOID:
                         subscriber = UnwrapProcessor.of(this.getMethod(), (Subscriber) getMethod()
                                 .invoke(getBeanInstance()));
                         break;
                     case INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID:
+                    case INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID:
                         subscriber = UnwrapProcessor.of(this.getMethod(),
                                 ((SubscriberBuilder) getMethod().invoke(getBeanInstance())).build());
                         break;
@@ -89,41 +91,4 @@ public Subscriber getSubscriber() {
         return subscriber;
     }
 
-    @Override
-    protected void resolveSignatureType() {
-        Class returnType = this.getMethod().getReturnType();
-        Class parameterType;
-        if (this.getMethod().getParameterTypes().length == 1) {
-            parameterType = this.getMethod().getParameterTypes()[0];
-        } else if (this.getMethod().getParameterTypes().length == 0) {
-            parameterType = Void.TYPE;
-        } else {
-            throw new DeploymentException(String
-                    .format("Unsupported parameters on incoming method %s", getMethod()));
-        }
-
-        if (Void.TYPE.equals(parameterType)) {
-            if (Subscriber.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_SUBSCRIBER_MSG_2_VOID);
-            } else if (SubscriberBuilder.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID);
-            }
-        } else {
-            if (CompletionStage.class.equals(returnType)) {
-                setType(MethodSignatureType.INCOMING_COMPLETION_STAGE_2_MSG);
-// Uncomment when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
-// see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
-            } else /*if (Void.TYPE.equals(returnType))*/ {
-                setType(MethodSignatureType.INCOMING_VOID_2_PAYL);
-//            } else {
-//                throw new DeploymentException("Not supported method signature.");
-            }
-        }
-
-        if (Objects.isNull(getType())) {
-            throw new DeploymentException(String
-                    .format("Unsupported incoming method signature %s", getMethod()));
-        }
-    }
-
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
index aadfb625b5c..5715561147f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
@@ -62,7 +62,7 @@ public void onNext(Object message) {
             Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, MessageUtils.unwrap(message, paramType)));
             subscription.request(1);
         } catch (Exception e) {
-            //Notify publisher to stop sending
+            // Notify publisher to stop sending
             subscription.cancel();
             throw new MessagingStreamException(e);
         }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolver.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolver.java
new file mode 100644
index 00000000000..9150e8c3961
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolver.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
+
+import javax.enterprise.inject.spi.DeploymentException;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+/**
+ * Method signature resolving utility, returns {@link MethodSignatureType} for any recognized signature.
+ * Throws {@link javax.enterprise.inject.spi.DeploymentException} for any un-recognized signature.
+ */
+public final class MethodSignatureResolver {
+    private final Class returnType;
+    private final Type genericReturnType;
+    private final Class[] parameterTypes;
+    private final Type[] genericParameterTypes;
+    private Method method;
+
+    private MethodSignatureResolver(Method method) {
+        this.method = method;
+        returnType = method.getReturnType();
+        genericReturnType = method.getGenericReturnType();
+        parameterTypes = method.getParameterTypes();
+        genericParameterTypes = method.getGenericParameterTypes();
+    }
+
+    /**
+     * Method signature resolving utility, returns {@link MethodSignatureType} for any recognized signature.
+     *
+     * @param method {@link java.lang.reflect.Method} to be resolved
+     * @return {@link MethodSignatureResolver}
+     */
+    public static MethodSignatureResolver create(Method method) {
+        return new MethodSignatureResolver(method);
+    }
+
+    /**
+     * Returns {@link MethodSignatureType} for any recognized signature.
+     * Throws {@link javax.enterprise.inject.spi.DeploymentException}
+     * for any un-recognized signature.
+     *
+     * @return {@link io.helidon.microprofile.messaging.channel.MethodSignatureType}
+     * of recognized signature
+     * @throws javax.enterprise.inject.spi.DeploymentException for un-recognized signature
+     */
+    public MethodSignatureType resolve() {
+        // INCOMING METHODS
+        if (returnsClassWithGenericParams(CompletionStage.class, MsgType.PAYLOAD) && hasFirstParam(MsgType.MESSAGE)) {
+            // CompletionStage method(Message msg)
+            return MethodSignatureType.INCOMING_COMPLETION_STAGE_2_MSG;
+        }
+        if (returnsClassWithGenericParams(CompletionStage.class, MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)
+                && isIncoming()) {
+            // CompletionStage method(I payload)
+            return MethodSignatureType.INCOMING_COMPLETION_STAGE_2_PAYL;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(SubscriberBuilder.class, MsgType.MESSAGE)) {
+            // SubscriberBuilder> method()
+            return MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(SubscriberBuilder.class, MsgType.PAYLOAD)) {
+            // SubscriberBuilder method()
+            return MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Subscriber.class, MsgType.MESSAGE)
+                && isIncoming()) {
+            // Subscriber> method()
+            return MethodSignatureType.INCOMING_SUBSCRIBER_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Subscriber.class, MsgType.PAYLOAD)
+                && isIncoming()) {
+            // Subscriber method()
+            return MethodSignatureType.INCOMING_SUBSCRIBER_PAYL_2_VOID;
+        }
+        if (returnsVoid() && hasFirstParam(MsgType.PAYLOAD)) {
+            // void method(I payload)
+            return MethodSignatureType.INCOMING_VOID_2_PAYL;
+        }
+        // PROCESSOR METHODS
+        if (returnsClassWithGenericParams(CompletionStage.class, MsgType.MESSAGE) && hasFirstParam(MsgType.MESSAGE)) {
+            // CompletionStage> method(Message msg)
+            return MethodSignatureType.PROCESSOR_COMPL_STAGE_MSG_2_MSG;
+        }
+        if (returnsClassWithGenericParams(CompletionStage.class, MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)) {
+            // CompletionStage method(I payload)
+            return MethodSignatureType.PROCESSOR_COMPL_STAGE_PAYL_2_PAYL;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(ProcessorBuilder.class, MsgType.MESSAGE)) {
+            // ProcessorBuilder, Message> method();
+            return MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(ProcessorBuilder.class, MsgType.PAYLOAD)) {
+            // ProcessorBuilder method();
+            return MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_PAYL_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Processor.class, MsgType.MESSAGE)) {
+            // Processor, Message> method();
+            return MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Processor.class, MsgType.PAYLOAD)) {
+            // Processor method();
+            return MethodSignatureType.PROCESSOR_PROCESSOR_PAYL_2_VOID;
+        }
+        if (returnsClassWithGenericParams(PublisherBuilder.class, MsgType.MESSAGE)
+                && hasFirstParamClassWithGeneric(PublisherBuilder.class, MsgType.MESSAGE)) {
+            // PublisherBuilder> method(PublisherBuilder> pub);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_MSG_2_PUBLISHER_BUILDER_MSG;
+        }
+        if (returnsClassWithGenericParams(PublisherBuilder.class, MsgType.PAYLOAD)
+                && hasFirstParamClassWithGeneric(PublisherBuilder.class, MsgType.PAYLOAD)) {
+            // PublisherBuilder method(PublisherBuilder pub);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PUBLISHER_BUILDER_PAYL;
+        }
+        if (returnsClassWithGenericParams(PublisherBuilder.class, MsgType.MESSAGE) && hasFirstParam(MsgType.MESSAGE)) {
+            // PublisherBuilder> method(Messagemsg);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_MSG_2_MSG;
+        }
+        if (returnsClassWithGenericParams(PublisherBuilder.class, MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)) {
+            // PublisherBuilder method( msg);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PAYL;
+        }
+        if (returnsClassWithGenericParams(Publisher.class, MsgType.MESSAGE)
+                && hasFirstParamClassWithGeneric(Publisher.class, MsgType.MESSAGE)) {
+            // Publisher> method(Publisher> pub);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_PUBLISHER_MSG;
+        }
+        if (returnsClassWithGenericParams(Publisher.class, MsgType.PAYLOAD)
+                && hasFirstParamClassWithGeneric(Publisher.class, MsgType.PAYLOAD)) {
+            // Publisher method(Publisher pub);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_PAYL_2_PUBLISHER_PAYL;
+        }
+        if (returnsClassWithGenericParams(Publisher.class, MsgType.MESSAGE) && hasFirstParam(MsgType.MESSAGE)) {
+            // Publisher> method(Messagemsg);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_MSG;
+        }
+        if (returnsClassWithGenericParams(Publisher.class, MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)) {
+            // Publisher method(I payload);
+            return MethodSignatureType.PROCESSOR_PUBLISHER_PAYL_2_PAYL;
+        }
+        if (returns(MsgType.MESSAGE) && hasFirstParam(MsgType.MESSAGE)) {
+            // Message method(Message msg)
+            return MethodSignatureType.PROCESSOR_MSG_2_MSG;
+        }
+        if (returns(MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)) {
+            // O method(I payload)
+            return MethodSignatureType.PROCESSOR_PAYL_2_PAYL;
+        }
+        // OUTGOING METHODS
+        if (hasNoParams() && returnsClassWithGenericParams(CompletionStage.class, MsgType.MESSAGE)) {
+            // CompletionStage> method()
+            return MethodSignatureType.OUTGOING_COMPLETION_STAGE_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(CompletionStage.class, MsgType.PAYLOAD)) {
+            // CompletionStage method()
+            return MethodSignatureType.OUTGOING_COMPLETION_STAGE_PAYL_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Publisher.class, MsgType.MESSAGE)) {
+            // Publisher> method()
+            return MethodSignatureType.OUTGOING_PUBLISHER_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(Publisher.class, MsgType.PAYLOAD)) {
+            // Publisher method()
+            return MethodSignatureType.OUTGOING_PUBLISHER_PAYL_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(PublisherBuilder.class, MsgType.MESSAGE)) {
+            // PublisherBuilder> method()
+            return MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_MSG_2_VOID;
+        }
+        if (hasNoParams() && returnsClassWithGenericParams(PublisherBuilder.class, MsgType.PAYLOAD)) {
+            // PublisherBuilder method()
+            return MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_PAYL_2_VOID;
+        }
+        if (hasNoParams() && returns(MsgType.MESSAGE)) {
+            // Message method()
+            return MethodSignatureType.OUTGOING_MSG_2_VOID;
+        }
+        if (hasNoParams() && returns(MsgType.PAYLOAD)) {
+            // U method()
+            return MethodSignatureType.OUTGOING_PAYL_2_VOID;
+        }
+        // Remove when TCK issue is solved https://github.com/eclipse/microprofile-reactive-messaging/issues/79
+        // see io.helidon.microprofile.messaging.inner.BadSignaturePublisherPayloadBean
+        if (returns(MsgType.PAYLOAD) && hasFirstParam(MsgType.PAYLOAD)) {
+            // O method(I payload)
+            return MethodSignatureType.INCOMING_VOID_2_PAYL;
+        }
+        // END OF BLOCK FOR REMOVE
+        throw new DeploymentException("Unsupported method signature " + method);
+    }
+
+    private boolean hasNoParams() {
+        return method.getParameterCount() == 0;
+    }
+
+    private boolean returnsVoid() {
+        return Void.TYPE.equals(returnType);
+    }
+
+    private boolean returns(MsgType msgType) {
+        if (returnsVoid()) return false;
+        return msgType == MsgType.MESSAGE && Message.class.isAssignableFrom(returnType)
+                || msgType == MsgType.PAYLOAD && !Message.class.isAssignableFrom(returnType);
+    }
+
+    private boolean hasFirstParam(MsgType msgType) {
+        if (hasNoParams()) return false;
+        Class firstParam = parameterTypes[0];
+        return msgType == MsgType.MESSAGE && Message.class.isAssignableFrom(firstParam)
+                || msgType == MsgType.PAYLOAD && !Message.class.equals(firstParam);
+    }
+
+    private boolean hasFirstParamClassWithGeneric(Class clazz, MsgType msgType) {
+        if (hasNoParams()) return false;
+        if (!clazz.isAssignableFrom(parameterTypes[0])) return false;
+
+        Type firstParam = genericParameterTypes[0];
+        if (!(firstParam instanceof ParameterizedType)) return false;
+
+        ParameterizedType paramReturnType = (ParameterizedType) firstParam;
+        Type[] actualTypeArguments = paramReturnType.getActualTypeArguments();
+
+        if (msgType == MsgType.MESSAGE) {
+            if (!(actualTypeArguments[0] instanceof ParameterizedType)) return false;
+            return Message.class.equals(((ParameterizedType) actualTypeArguments[0]).getRawType());
+        } else {
+            return !Message.class.equals(firstParam);
+        }
+    }
+
+    private boolean returnsClassWithGenericParams(Class clazz, MsgType msgType) {
+        if (returnsVoid()) return false;
+        if (!clazz.isAssignableFrom(returnType)) return false;
+        if (!(genericReturnType instanceof ParameterizedType)) return false;
+
+        ParameterizedType paramReturnType = (ParameterizedType) genericReturnType;
+        Type[] actualTypeArguments = paramReturnType.getActualTypeArguments();
+
+        if (actualTypeArguments.length == 0) return false;
+
+        if (msgType == MsgType.MESSAGE) {
+            if (!(actualTypeArguments[0] instanceof ParameterizedType)) return false;
+            return Message.class.equals(((ParameterizedType) actualTypeArguments[0]).getRawType());
+        } else if (msgType == MsgType.WILDCARD) {
+            return actualTypeArguments[0] instanceof WildcardType;
+        } else {
+            if ((actualTypeArguments[0] instanceof ParameterizedType)) {
+                if (Message.class.equals(((ParameterizedType) actualTypeArguments[0]).getRawType())) return false;
+            }
+            return !Message.class.equals(actualTypeArguments[0]);
+        }
+    }
+
+    private boolean isIncoming() {
+        return hasAnnotation(Incoming.class) && !hasAnnotation(Outgoing.class);
+    }
+
+    private boolean isOutgoing() {
+        return !hasAnnotation(Incoming.class) && hasAnnotation(Outgoing.class);
+    }
+
+    private boolean isProcessor() {
+        return hasAnnotation(Incoming.class) && hasAnnotation(Outgoing.class);
+    }
+
+    private  boolean hasAnnotation(Class clazz) {
+        T annotation = method.getAnnotation(clazz);
+        return Objects.nonNull(annotation);
+    }
+
+    private enum MsgType {
+        MESSAGE, PAYLOAD, WILDCARD;
+    }
+}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
index 70a82c26886..a215b725eeb 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
@@ -81,16 +81,43 @@ public enum MethodSignatureType {
      * Processor method signature type.
      * 
    
      * Invoke at: assembly time
-     * 
    Publisher<Message<O>> method(Message<I> msg);
    
-     * 
    Publisher<O> method(I payload);
    
+     * 
    Publisher<Message<O>> method(Publisher<Message<I>> pub);
    
+     * 
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     */
+    PROCESSOR_PUBLISHER_MSG_2_PUBLISHER_MSG(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: assembly time
+     * 
    Publisher<O> method(Publisher<I> pub);
    
      * 
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_PUBLISHER_2_PUBLISHER(true, Acknowledgment.Strategy.PRE_PROCESSING,
+    PROCESSOR_PUBLISHER_PAYL_2_PUBLISHER_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
             Acknowledgment.Strategy.PRE_PROCESSING
     ),
+    /**
+     * Processor method signature type.
+     * 
    
+     * Invoke at: assembly time
+     * 
    PublisherBuilder<Message<O>> method(PublisherBuilder<Message<I>> pub);
    
+     * 
    
+     * 
  • Default acknowledgment strategy: PRE_PROCESSING
+     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     */
+    PROCESSOR_PUBLISHER_BUILDER_MSG_2_PUBLISHER_BUILDER_MSG(true, Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.NONE,
+            Acknowledgment.Strategy.MANUAL,
+            Acknowledgment.Strategy.PRE_PROCESSING
+    ),
     /**
      * Processor method signature type.
      * 
    
@@ -100,7 +127,7 @@ public enum MethodSignatureType {
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER(true, Acknowledgment.Strategy.PRE_PROCESSING,
+    PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PUBLISHER_BUILDER_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
             Acknowledgment.Strategy.PRE_PROCESSING
     ),
@@ -108,7 +135,7 @@ public enum MethodSignatureType {
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
-     * 
    Publisher<Message<O>> method(Message<I>msg);
    
+     * 
    Publisher<Message<O>> method(Message<I> msg);
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      */
@@ -120,12 +147,12 @@ public enum MethodSignatureType {
     /**
      * Processor method signature type.
      * 
    
-     * Invoke at: assembly time
+     * Invoke at: every incoming
      * 
    Publisher<O> method(I payload);
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
-    PROCESSOR_PUBLISHER_PAYL_2_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
+    PROCESSOR_PUBLISHER_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
             Acknowledgment.Strategy.PRE_PROCESSING
     ),
@@ -133,7 +160,7 @@ public enum MethodSignatureType {
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
-     * 
    PublisherBuilder<Message<O>> method(Message<I>msg);
    
+     * 
    PublisherBuilder<Message<O>> method(Message<I> msg);
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      */
@@ -146,7 +173,7 @@ public enum MethodSignatureType {
      * Processor method signature type.
      * 
    
      * Invoke at: every incoming
-     * 
    PublisherBuilder<O> method(<I> msg);
    
+     * 
    PublisherBuilder<O> method(I payload);
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      */
@@ -278,7 +305,7 @@ public enum MethodSignatureType {
      * Subscriber method signature type.
      * 
    
      * Invoke at: every incoming
-     * 
    CompletionStage<?> method(Message<I>msg)
    
+     * 
    CompletionStage<?> method(Message<I> msg)
    
      * 
  • Default acknowledgment strategy: PRE_PROCESSING
      * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
      */
@@ -307,25 +334,38 @@ public enum MethodSignatureType {
      * 
    
      * Invoke at: assembly time
      * 
    Publisher<Message<U>> method()
    
+     */
+    OUTGOING_PUBLISHER_MSG_2_VOID(true, null),
+
+    /**
+     * Publisher method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    Publisher<U> method()
    
      */
-    OUTGOING_PUBLISHER_2_VOID(true, null),
+    OUTGOING_PUBLISHER_PAYL_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
      * 
    
      * Invoke at: assembly time
      * 
    PublisherBuilder<Message<U>> method()
    
+     */
+    OUTGOING_PUBLISHER_BUILDER_MSG_2_VOID(true, null),
+
+    /**
+     * Publisher method signature type.
+     * 
    
+     * Invoke at: assembly time
      * 
    PublisherBuilder<U> method()
    
      */
-    OUTGOING_PUBLISHER_BUILDER_2_VOID(true, null),
+    OUTGOING_PUBLISHER_BUILDER_PAYL_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
      * 
    
      * Invoke at: Each request made by subscriber
      * 
    Message<U> method()
    
-     * 
    U method()
    
      * 
    
      * Produces an infinite stream of Message associated with the
      * channel channel. The result is a CompletionStage. The method should not be
@@ -334,11 +374,36 @@ public enum MethodSignatureType {
      */
     OUTGOING_MSG_2_VOID(false, null),
 
+    /**
+     * Publisher method signature type.
+     * 
    
+     * Invoke at: Each request made by subscriber
+     * 
    U method()
    
+     * 
    
+     * Produces an infinite stream of Message associated with the
+     * channel channel. The result is a CompletionStage. The method should not be
+     * called by the reactive messaging implementation until the CompletionStage
+     * returned previously is completed.
+     */
+    OUTGOING_PAYL_2_VOID(false, null),
+
     /**
      * Publisher method signature type.
      * 
    
      * Invoke at: Each request made by subscriber
      * 
    CompletionStage<Message<U>> method()
    
+     * 
    
+     * Produces an infinite stream of Message associated with the
+     * channel channel. The result is a CompletionStage. The method should not be
+     * called by the reactive messaging implementation until the CompletionStage
+     * returned previously is completed.
+     */
+    OUTGOING_COMPLETION_STAGE_MSG_2_VOID(false, null),
+
+    /**
+     * Publisher method signature type.
+     * 
    
+     * Invoke at: Each request made by subscriber
      * 
    CompletionStage<U> method()
    
      * 
    
      * Produces an infinite stream of Message associated with the
@@ -346,7 +411,7 @@ public enum MethodSignatureType {
      * called by the reactive messaging implementation until the CompletionStage
      * returned previously is completed.
      */
-    OUTGOING_COMPLETION_STAGE_2_VOID(false, null);
+    OUTGOING_COMPLETION_STAGE_PAYL_2_VOID(false, null);
 
     private boolean invokeAtAssembly;
     private Acknowledgment.Strategy defaultAckType;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
index 1b607080f5d..183cce9da18 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -18,8 +18,6 @@
 package io.helidon.microprofile.messaging.channel;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.Objects;
-import java.util.concurrent.CompletionStage;
 
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
@@ -46,10 +44,12 @@ public void init(BeanManager beanManager, Config config) {
         if (getType().isInvokeAtAssembly()) {
             try {
                 switch (getType()) {
-                    case OUTGOING_PUBLISHER_2_VOID:
+                    case OUTGOING_PUBLISHER_MSG_2_VOID:
+                    case OUTGOING_PUBLISHER_PAYL_2_VOID:
                         publisher = (Publisher) getMethod().invoke(getBeanInstance());
                         break;
-                    case OUTGOING_PUBLISHER_BUILDER_2_VOID:
+                    case OUTGOING_PUBLISHER_BUILDER_MSG_2_VOID:
+                    case OUTGOING_PUBLISHER_BUILDER_PAYL_2_VOID:
                         publisher = ((PublisherBuilder) getMethod().invoke(getBeanInstance())).buildRs();
                         break;
                     default:
@@ -80,30 +80,4 @@ public Publisher getPublisher() {
         return publisher;
     }
 
-    @Override
-    protected void resolveSignatureType() {
-        Class returnType = this.getMethod().getReturnType();
-        if (this.getMethod().getParameterTypes().length != 0) {
-            throw new DeploymentException(String
-                    .format("Unsupported parameters on outgoing method %s", getMethod()));
-        }
-
-        if (Void.class.isAssignableFrom(returnType)) {
-            setType(null);
-        } else if (Publisher.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_PUBLISHER_2_VOID);
-        } else if (PublisherBuilder.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_2_VOID);
-        } else if (CompletionStage.class.isAssignableFrom(returnType)) {
-            setType(MethodSignatureType.OUTGOING_COMPLETION_STAGE_2_VOID);
-        } else {
-            setType(MethodSignatureType.OUTGOING_MSG_2_VOID);
-        }
-
-        if (Objects.isNull(getType())) {
-            throw new DeploymentException(String
-                    .format("Unsupported outgoing method signature %s", getMethod()));
-        }
-    }
-
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index b6ca2441c0f..5ef0c2d2949 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -17,9 +17,6 @@
 
 package io.helidon.microprofile.messaging.channel;
 
-import java.lang.reflect.Method;
-import java.util.concurrent.CompletionStage;
-
 import javax.enterprise.inject.spi.AnnotatedMethod;
 import javax.enterprise.inject.spi.BeanManager;
 import javax.enterprise.inject.spi.DeploymentException;
@@ -28,10 +25,7 @@
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
-import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
 
 class ProcessorMethod extends AbstractMethod {
 
@@ -84,47 +78,4 @@ void setOutgoingChannel(UniversalChannel outgoingChannel) {
         this.outgoingChannel = outgoingChannel;
     }
 
-    @Override
-    protected void resolveSignatureType() {
-        Method method = getMethod();
-        Class returnType = method.getReturnType();
-        Class parameterType = Void.TYPE;
-
-        if (method.getParameterTypes().length == 1) {
-            parameterType = method.getParameterTypes()[0];
-
-        } else if (method.getParameterTypes().length > 1) {
-            throw new DeploymentException(String
-                    .format("Bad processor method signature %s", method));
-        }
-        if (Void.TYPE.equals(parameterType)) {
-            if (Processor.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID);
-
-            } else if (ProcessorBuilder.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID);
-
-            } else {
-                throw new DeploymentException(String
-                        .format("Bad processor method signature %s", method));
-            }
-        } else if (Publisher.class.equals(parameterType) && Publisher.class.equals(returnType)) {
-            setType(MethodSignatureType.PROCESSOR_PUBLISHER_2_PUBLISHER);
-
-        } else if (PublisherBuilder.class.equals(parameterType) && PublisherBuilder.class.equals(returnType)) {
-            setType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER);
-
-        } else {
-            if (Publisher.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_MSG);
-
-            } else if (CompletionStage.class.equals(returnType)) {
-                setType(MethodSignatureType.PROCESSOR_COMPL_STAGE_MSG_2_MSG);
-
-            } else {
-                setType(MethodSignatureType.PROCESSOR_MSG_2_MSG);
-            }
-        }
-    }
-
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
index ecb594402c4..98409eed39a 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
@@ -52,31 +52,36 @@ class ProxyProcessor implements Processor {
     ProxyProcessor(ProcessorMethod processorMethod) {
         this.processorMethod = processorMethod;
         try {
-            if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_2_PUBLISHER_BUILDER) {
-                PublisherBuilder paramPublisherBuilder = ReactiveStreams.fromPublisher(this);
-                publisher = ((PublisherBuilder) processorMethod
-                        .getMethod()
-                        .invoke(processorMethod.getBeanInstance(), paramPublisherBuilder)).buildRs();
-
-            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PUBLISHER_2_PUBLISHER) {
-                publisher = ((Publisher) processorMethod
-                        .getMethod()
-                        .invoke(processorMethod.getBeanInstance(), this));
-
-            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID) {
-                processor = ((ProcessorBuilder) processorMethod
-                        .getMethod()
-                        .invoke(processorMethod.getBeanInstance())).buildRs();
-                publisher = processor;
-
-            } else if (processorMethod.getType() == MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID) {
-                processor = ((Processor) processorMethod
-                        .getMethod()
-                        .invoke(processorMethod.getBeanInstance()));
-                publisher = processor;
-
-            } else {
-                throw new UnsupportedOperationException("Unknown signature type " + processorMethod.getType());
+            switch (processorMethod.getType()) {
+                case PROCESSOR_PUBLISHER_BUILDER_MSG_2_PUBLISHER_BUILDER_MSG:
+                case PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PUBLISHER_BUILDER_PAYL:
+                    PublisherBuilder paramPublisherBuilder = ReactiveStreams.fromPublisher(this);
+                    publisher = ((PublisherBuilder) processorMethod
+                            .getMethod()
+                            .invoke(processorMethod.getBeanInstance(), paramPublisherBuilder)).buildRs();
+                    break;
+                case PROCESSOR_PUBLISHER_MSG_2_PUBLISHER_MSG:
+                case PROCESSOR_PUBLISHER_PAYL_2_PUBLISHER_PAYL:
+                    publisher = ((Publisher) processorMethod
+                            .getMethod()
+                            .invoke(processorMethod.getBeanInstance(), this));
+                    break;
+                case PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID:
+                case PROCESSOR_PROCESSOR_BUILDER_PAYL_2_VOID:
+                    processor = ((ProcessorBuilder) processorMethod
+                            .getMethod()
+                            .invoke(processorMethod.getBeanInstance())).buildRs();
+                    publisher = processor;
+                    break;
+                case PROCESSOR_PROCESSOR_MSG_2_VOID:
+                case PROCESSOR_PROCESSOR_PAYL_2_VOID:
+                    processor = ((Processor) processorMethod
+                            .getMethod()
+                            .invoke(processorMethod.getBeanInstance()));
+                    publisher = processor;
+                    break;
+                default:
+                    throw new UnsupportedOperationException("Unknown signature type " + processorMethod.getType());
             }
         } catch (IllegalAccessException | InvocationTargetException e) {
             throw new DeploymentException(e);
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
new file mode 100644
index 00000000000..460ffaf4029
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CompletionStage;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
+
+class MethodSignatureResolverTest {
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_COMPLETION_STAGE_2_MSG)
+    CompletionStage incoming_completion_stage_2_msg(Message msg) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_COMPLETION_STAGE_2_PAYL)
+    CompletionStage incoming_completion_stage_2_payl(String payload) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID)
+    SubscriberBuilder, Void> incoming_subscriber_builder_msg_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID)
+    SubscriberBuilder incoming_subscriber_builder_payl_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_SUBSCRIBER_MSG_2_VOID)
+    Subscriber> incoming_subscriber_msg_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_SUBSCRIBER_PAYL_2_VOID)
+    Subscriber incoming_subscriber_payl_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.INCOMING_VOID_2_PAYL)
+    void incoming_void_2_payl(String payload) {
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_MSG_2_VOID)
+    PublisherBuilder> outgoing_publisher_builder_msg_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PUBLISHER_BUILDER_PAYL_2_VOID)
+    PublisherBuilder outgoing_publisher_builder_payl_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PUBLISHER_MSG_2_VOID)
+    Publisher> outgoing_publisher_msg_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PUBLISHER_PAYL_2_VOID)
+    Publisher outgoing_publisher_payl_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_COMPLETION_STAGE_MSG_2_VOID)
+    CompletionStage> outgoing_completion_stage_msg_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_COMPLETION_STAGE_PAYL_2_VOID)
+    CompletionStage outgoing_completion_stage_payl_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_MSG_2_VOID)
+    Message outgoing_msg_2_void() {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PAYL_2_VOID)
+    String outgoing_payl_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID)
+    ProcessorBuilder, Message> processor_processor_builder_msg_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PROCESSOR_BUILDER_PAYL_2_VOID)
+    ProcessorBuilder processor_processor_builder_payl_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PROCESSOR_MSG_2_VOID)
+    Processor, Message> processor_processor_msg_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PROCESSOR_PAYL_2_VOID)
+    Processor processor_processor_payl_2_void() {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_MSG_2_PUBLISHER_BUILDER_MSG)
+    PublisherBuilder> processor_publisher_builder_msg_2_publisher_builder_msg(PublisherBuilder> pub) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PUBLISHER_BUILDER_PAYL)
+    PublisherBuilder processor_publisher_builder_payl_2_publisher_builder_payl(PublisherBuilder pub) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_MSG_2_MSG)
+    PublisherBuilder> processor_publisher_builder_msg_2_msg(Message msg) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PAYL)
+    PublisherBuilder processor_publisher_builder_payl_2_payl(String payload) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_PUBLISHER_MSG)
+    Publisher> processor_publisher_msg_2_publisher_msg(Publisher> pub) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_PAYL_2_PUBLISHER_PAYL)
+    Publisher processor_publisher_payl_2_publisher_payl(Publisher pub) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_MSG_2_MSG)
+    Publisher> processor_publisher_msg_2_msg(Message msg) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PUBLISHER_PAYL_2_PAYL)
+    Publisher processor_publisher_payl_2_payl(String payload) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_COMPL_STAGE_MSG_2_MSG)
+    CompletionStage> processor_compl_stage_msg_2_msg(Message msg) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_COMPL_STAGE_PAYL_2_PAYL)
+    CompletionStage processor_compl_stage_payl_2_payl(String payload) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_MSG_2_MSG)
+    Message processor_msg_2_msg(Message msg) {
+        return null;
+    }
+
+    @Incoming("in-channel-name")
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.PROCESSOR_PAYL_2_PAYL)
+    String processor_payl_2_payl(String payload) {
+        return null;
+    }
+
+    @Outgoing("out-channel-name")
+    @ExpectedSignatureType(MethodSignatureType.OUTGOING_PUBLISHER_PAYL_2_VOID)
+    public HybridPublisher extendedPublisher() {
+        return null;
+    }
+
+    private static Stream locateTestMethods() {
+        return Arrays.stream(MethodSignatureResolverTest.class.getDeclaredMethods())
+                .filter(m -> Objects.nonNull(m.getAnnotation(ExpectedSignatureType.class)))
+                .sorted(Comparator.comparing(Method::getName))
+                .map(MethodTestCase::new);
+    }
+
+    @ParameterizedTest
+    @MethodSource("locateTestMethods")
+    void signatureResolving(MethodTestCase testCase) {
+        assertEquals(testCase.expectedType, MethodSignatureResolver.create(testCase.m).resolve());
+    }
+
+    @Test
+    void testSignatureResolvingCoverage() {
+        Set testedTypes = locateTestMethods().map(m -> m.expectedType).collect(Collectors.toSet());
+        Set unTestedTypes = Arrays.stream(MethodSignatureType.values())
+                .filter(o -> !testedTypes.contains(o))
+                .map(MethodSignatureType::name)
+                .collect(Collectors.toSet());
+        if (!unTestedTypes.isEmpty()) {
+            fail("No test found for signature types: \n" + String.join("\n", unTestedTypes));
+        }
+    }
+
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.RUNTIME)
+    private @interface ExpectedSignatureType {
+        MethodSignatureType value();
+    }
+
+    private static class MethodTestCase {
+        private final MethodSignatureType expectedType;
+        private final Method m;
+
+        MethodTestCase(Method m) {
+            this.m = m;
+            this.expectedType = m.getAnnotation(ExpectedSignatureType.class).value();
+        }
+
+        @Override
+        public String toString() {
+            return expectedType.name();
+        }
+    }
+}
\ No newline at end of file
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/SignatureTypeConsistencyTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/SignatureTypeConsistencyTest.java
new file mode 100644
index 00000000000..610a2b8318d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/SignatureTypeConsistencyTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class SignatureTypeConsistencyTest {
+
+    /**
+     * To keep consistency between {@link io.helidon.microprofile.messaging.channel.MethodSignatureType}
+     * and {@link MethodSignatureResolver}
+     */
+    @Test
+    void isTypeUsedByResolver() throws IOException {
+        String srcFileName = String.format("%s.java", MethodSignatureResolver.class.getName().replaceAll("\\.", File.separator));
+        Path resolverSrcPath = Paths.get("src", "main", "java", srcFileName);
+        String resolverSrc = new String(Files.readAllBytes(resolverSrcPath));
+
+        Arrays.stream(MethodSignatureType.values())
+                .map(signatureType -> MethodSignatureType.class.getSimpleName() + "." + signatureType.name())
+                .filter(token -> !resolverSrc.contains(token))
+                .map(token -> String.format("Unused signature type, token %s not found in file %s", token, resolverSrcPath))
+                .forEach(Assertions::fail);
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
index fce4f22d84f..f2d2c04face 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
@@ -17,19 +17,21 @@
 
 package io.helidon.microprofile.messaging.kafka;
 
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.messaging.Message;
-
-import javax.enterprise.context.ApplicationScoped;
-
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.CountDownLatch;
 
+import javax.enterprise.context.ApplicationScoped;
+
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+
 @ApplicationScoped
 public class KafkaConsumingBean {
 
@@ -38,9 +40,10 @@ public class KafkaConsumingBean {
     public static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() * 2);
 
     @Incoming("test-channel-1")
-    public void receiveMPMessage(Message> msg) {
+    public CompletionStage receiveMPMessage(Message> msg) {
         assertTrue(TEST_DATA.contains(msg.getPayload().value()));
         testChannelLatch.countDown();
+        return CompletableFuture.completedFuture(null);
     }
 
     @Incoming("test-channel-2")
diff --git a/pom.xml b/pom.xml
index 8cf1ae927cb..d298ca374d6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -153,6 +153,7 @@
         media
         webserver
         security
+        messaging
         microprofile
         tracing
         bundles

From 5882f1d4dd8688d75c80d5de3bd059f9a58a34e6 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 23 Nov 2019 09:02:04 +0100
Subject: [PATCH 23/66] Checkstyle fixes

Signed-off-by: Daniel Kec 
---
 messaging/kafka/pom.xml                       | 34 ++++++++++++-
 .../kafka/InvalidKafkaConsumerState.java      |  8 +--
 .../kafka/KafkaConfigProperties.java          | 15 +++---
 .../kafka/PartitionsAssignedLatch.java        | 10 ++--
 .../messaging/kafka/SimpleKafkaConsumer.java  | 39 +++++++++-----
 .../messaging/kafka/SimpleKafkaProducer.java  | 31 +++++++----
 .../connector/KafkaConnectorFactory.java      | 28 ++++++----
 .../kafka/connector/KafkaMessage.java         | 16 ++++--
 .../kafka/connector/SimplePublisher.java      | 10 ++--
 .../connector/SimplePublisherBuilder.java     | 51 +++++++++++--------
 .../kafka/connector/package-info.java         | 21 ++++++++
 .../helidon/messaging/kafka/package-info.java | 21 ++++++++
 .../messaging/kafka/SimpleKafkaTest.java      | 16 +++---
 13 files changed, 213 insertions(+), 87 deletions(-)
 create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/package-info.java
 create mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/package-info.java

diff --git a/messaging/kafka/pom.xml b/messaging/kafka/pom.xml
index ff7a2f6799d..954e6a0c0b6 100644
--- a/messaging/kafka/pom.xml
+++ b/messaging/kafka/pom.xml
@@ -22,6 +22,12 @@
 
     4.0.0
 
+    
+        io.helidon.messaging
+        helidon-messaging-project
+        1.3.2-SNAPSHOT
+    
+
     io.helidon.messaging.connectors
     kafka-connector
     1.3.2-SNAPSHOT
@@ -54,7 +60,7 @@
         
             io.helidon.config
             helidon-config-yaml
-            1.2.2-SNAPSHOT
+            1.3.2-SNAPSHOT
         
         
             io.helidon.microprofile.config
@@ -99,11 +105,35 @@
     
 
     
+        
+            
+                
+                    org.apache.maven.plugins
+                    maven-checkstyle-plugin
+                    ${version.plugin.checkstyle}
+                    
+                        ${project.build.sourceDirectory}
+                    
+                    
+                        
+                            com.puppycrawl.tools
+                            checkstyle
+                            ${version.lib.checkstyle}
+                            
+                                
+                                    com.sun
+                                    tools
+                                
+                            
+                        
+                    
+                
+            
+        
         
             
                 org.apache.maven.plugins
                 maven-surefire-plugin
-                3.0.0-M3
                 
                     
                         
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java
index d256e3b9dce..702d8311cdb 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/InvalidKafkaConsumerState.java
@@ -17,16 +17,16 @@
 package io.helidon.messaging.kafka;
 
 /**
- * Runtime exception for Consumer validation errors
+ * Runtime exception for Consumer validation errors.
  */
-public class InvalidKafkaConsumerState extends RuntimeException {
+class InvalidKafkaConsumerState extends RuntimeException {
 
     /**
-     * Creates {@link io.helidon.messaging.kafka.InvalidKafkaConsumerState} runtime exception
+     * Creates {@link io.helidon.messaging.kafka.InvalidKafkaConsumerState} runtime exception.
      *
      * @param message the message
      */
-    public InvalidKafkaConsumerState(String message) {
+    InvalidKafkaConsumerState(String message) {
         super(message);
     }
 }
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java
index 8504e9e1937..409c8ef4a6a 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/KafkaConfigProperties.java
@@ -16,14 +16,13 @@
 
 package io.helidon.messaging.kafka;
 
-import io.helidon.config.Config;
-import io.helidon.config.ConfigValue;
-
 import java.util.Arrays;
 import java.util.List;
 import java.util.Properties;
 import java.util.stream.Collectors;
 
+import io.helidon.config.Config;
+
 /**
  * Prepare Kafka properties from Helidon {@link io.helidon.config.Config Config}.
  * Configuration format as specified in the MicroProfile Reactive Messaging
@@ -52,15 +51,15 @@
  *
  * @see io.helidon.config.Config
  */
-public class KafkaConfigProperties extends Properties {
+class KafkaConfigProperties extends Properties {
 
     /**
-     * Topic or topics delimited by commas
+     * Topic or topics delimited by commas.
      */
     static final String TOPIC_NAME = "topic";
 
     /**
-     * Consumer group id
+     * Consumer group id.
      */
     static final String GROUP_ID = "group.id";
 
@@ -68,14 +67,14 @@ public class KafkaConfigProperties extends Properties {
      * Prepare Kafka properties from Helidon {@link io.helidon.config.Config Config},
      * underscores in keys are translated to dots.
      *
-     * @param config   parent config of kafka key
+     * @param config parent config of kafka key
      */
     KafkaConfigProperties(Config config) {
         config.asNodeList().get().forEach(this::addProperty);
     }
 
     /**
-     * Split comma separated topic names
+     * Split comma separated topic names.
      *
      * @return list of topic names
      */
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java
index 268b6a26f27..937f2f9c2e5 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/PartitionsAssignedLatch.java
@@ -16,18 +16,18 @@
 
 package io.helidon.messaging.kafka;
 
-import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
-import org.apache.kafka.common.TopicPartition;
-
 import java.util.Collection;
 import java.util.concurrent.CountDownLatch;
 
+import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
+import org.apache.kafka.common.TopicPartition;
+
 /**
- * Waiting latch for partition assigment, after that is consumer ready to receive
+ * Waiting latch for partition assigment, after that is consumer ready to receive.
  */
 public class PartitionsAssignedLatch extends CountDownLatch implements ConsumerRebalanceListener {
 
-    public PartitionsAssignedLatch() {
+    PartitionsAssignedLatch() {
         super(1);
     }
 
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
index 53eaa4c5189..39744940ac7 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
@@ -16,14 +16,6 @@
 
 package io.helidon.messaging.kafka;
 
-import io.helidon.config.Config;
-import io.helidon.messaging.kafka.connector.KafkaMessage;
-import io.helidon.messaging.kafka.connector.SimplePublisherBuilder;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.apache.kafka.clients.consumer.ConsumerRecords;
-import org.apache.kafka.clients.consumer.KafkaConsumer;
-import org.apache.kafka.common.errors.WakeupException;
-
 import java.io.Closeable;
 import java.time.Duration;
 import java.util.ArrayList;
@@ -40,6 +32,15 @@
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
+import io.helidon.config.Config;
+import io.helidon.messaging.kafka.connector.KafkaMessage;
+import io.helidon.messaging.kafka.connector.SimplePublisherBuilder;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.common.errors.WakeupException;
+
 /**
  * Simple Kafka consumer covering basic use-cases.
  * Configurable by Helidon {@link io.helidon.config.Config Config},
@@ -101,6 +102,12 @@ public SimpleKafkaConsumer(String channelName, Config config, String consumerGro
         consumer = new KafkaConsumer<>(properties);
     }
 
+    /**
+     * Kafka consumer created from {@link io.helidon.config.Config config}
+     * see configuration {@link KafkaConfigProperties example}.
+     *
+     * @param config Helidon {@link io.helidon.config.Config config}
+     */
     public SimpleKafkaConsumer(Config config) {
         properties = new KafkaConfigProperties(config);
         properties.setProperty(KafkaConfigProperties.GROUP_ID, getOrGenerateGroupId(null));
@@ -110,16 +117,17 @@ public SimpleKafkaConsumer(Config config) {
     }
 
     /**
-     * Execute supplied consumer for each received record
+     * Execute supplied consumer for each received record.
      *
      * @param function to be executed for each received record
+     * @return {@link java.util.concurrent.Future}
      */
     public Future consumeAsync(Consumer> function) {
         return this.consumeAsync(Executors.newWorkStealingPool(), null, function);
     }
 
     /**
-     * Execute supplied consumer by provided executor service for each received record
+     * Execute supplied consumer by provided executor service for each received record.
      *
      * @param executorService Custom executor service used for spinning up polling thread and record consuming threads
      * @param customTopics    Can be null, list of topics appended to the list from configuration
@@ -159,6 +167,12 @@ public Future consumeAsync(ExecutorService executorService, List cust
         });
     }
 
+    /**
+     * Create publisher builder.
+     *
+     * @param executorService {@link java.util.concurrent.ExecutorService}
+     * @return {@link io.helidon.messaging.kafka.connector.SimplePublisherBuilder}
+     */
     public SimplePublisherBuilder createPublisherBuilder(ExecutorService executorService) {
         validateConsumer();
         this.externalExecutorService = executorService;
@@ -211,7 +225,7 @@ public void waitForPartitionAssigment(long timeout, TimeUnit unit) throws Interr
 
     /**
      * Close consumer gracefully. Stops polling loop,
-     * wakes possible blocked poll and shuts down executor service
+     * wakes possible blocked poll and shuts down executor service.
      */
     @Override
     public void close() {
@@ -223,9 +237,10 @@ public void close() {
     /**
      * Use supplied customGroupId if not null
      * or take it from configuration if exist
-     * or generate random in this order
+     * or generate random in this order.
      *
      * @param customGroupId custom group.id, overrides group.id from configuration
+     * @return returns or generate new groupId
      */
     protected String getOrGenerateGroupId(String customGroupId) {
         return Optional.ofNullable(customGroupId)
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
index 9cecda53ea0..46a12a5ac62 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
@@ -16,12 +16,6 @@
 
 package io.helidon.messaging.kafka;
 
-import io.helidon.config.Config;
-import org.apache.kafka.clients.producer.KafkaProducer;
-import org.apache.kafka.clients.producer.ProducerRecord;
-import org.apache.kafka.clients.producer.RecordMetadata;
-import org.apache.kafka.common.header.Header;
-
 import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -31,10 +25,17 @@
 import java.util.concurrent.Future;
 import java.util.logging.Logger;
 
+import io.helidon.config.Config;
+
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.header.Header;
+
 /**
  * Simple Kafka producer covering basic use-cases.
  * Configurable by Helidon {@link io.helidon.config.Config Config},
- * For more info about configuration see {@link KafkaConfigProperties}
+ * For more info about configuration see {@link KafkaConfigProperties}.
  * 
    
  * Usage:
  * 
    {@code new SimpleKafkaProducer("job-done-producer", Config.create())
@@ -67,6 +68,12 @@ public SimpleKafkaProducer(String producerId, Config config) {
         producer = new KafkaProducer<>(properties);
     }
 
+    /**
+     * Kafka producer created from {@link io.helidon.config.Config config} under kafka->producerId,
+     * see configuration {@link KafkaConfigProperties example}.
+     *
+     * @param config Helidon {@link io.helidon.config.Config config}
+     */
     public SimpleKafkaProducer(Config config) {
         properties = new KafkaConfigProperties(config);
         producer = new KafkaProducer<>(properties);
@@ -74,7 +81,7 @@ public SimpleKafkaProducer(Config config) {
 
     /**
      * Send record to all provided topics,
-     * blocking until all records are acknowledged by broker
+     * blocking until all records are acknowledged by broker.
      *
      * @param value Will be serialized by value.serializer class
      *              defined in {@link KafkaConfigProperties configuration}
@@ -95,12 +102,18 @@ public List produce(V value) {
         return metadataList;
     }
 
+    /**
+     * Produce asynchronously.
+     *
+     * @param value value to be produced
+     * @return list of futures
+     */
     public List> produceAsync(V value) {
         return this.produceAsync(null, null, null, null, value, null);
     }
 
     /**
-     * Send record to all provided topics, don't wait for server acknowledgement
+     * Send record to all provided topics, don't wait for server acknowledgement.
      *
      * @param customTopics Can be null, list of topics appended to the list from configuration,
      *                     record will be sent to all topics iteratively
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
index 4c3a46905c7..133330a949a 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
@@ -16,34 +16,43 @@
 
 package io.helidon.messaging.kafka.connector;
 
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.BeforeDestroyed;
+import javax.enterprise.event.Observes;
+
 import io.helidon.common.configurable.ThreadPoolSupplier;
 import io.helidon.config.Config;
 import io.helidon.messaging.kafka.SimpleKafkaConsumer;
 import io.helidon.microprofile.config.MpConfig;
+
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.spi.Connector;
 import org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.context.BeforeDestroyed;
-import javax.enterprise.event.Observes;
-
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-
 /**
- * Partial implementation of Connector as described in the MicroProfile Reactive Messaging Specification
+ * Partial implementation of Connector as described in the MicroProfile Reactive Messaging Specification.
  */
 @ApplicationScoped
 @Connector(KafkaConnectorFactory.CONNECTOR_NAME)
 public class KafkaConnectorFactory implements IncomingConnectorFactory {
 
+    /**
+     * Microprofile messaging Kafka connector name.
+     */
     public static final String CONNECTOR_NAME = "helidon-kafka";
 
     private List> consumers = new CopyOnWriteArrayList<>();
     private ThreadPoolSupplier threadPoolSupplier = null;
 
+    /**
+     * Called when container is terminated.
+     *
+     * @param event termination event
+     */
     public void terminate(@Observes @BeforeDestroyed(ApplicationScoped.class) Object event) {
         consumers.forEach(SimpleKafkaConsumer::close);
     }
@@ -61,9 +70,6 @@ public PublisherBuilder> getPublisherBuilder(org.eclipse.mi
     }
 
     private ThreadPoolSupplier getThreadPoolSupplier(Config config) {
-        if (this.threadPoolSupplier != null) {
-            return this.threadPoolSupplier;
-        }
         synchronized (this) {
             if (this.threadPoolSupplier != null) {
                 return this.threadPoolSupplier;
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
index b794989bc0a..b106181370e 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
@@ -16,14 +16,14 @@
 
 package io.helidon.messaging.kafka.connector;
 
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.eclipse.microprofile.reactive.messaging.Message;
-
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.eclipse.microprofile.reactive.messaging.Message;
+
 /**
- * Kafka specific MP messaging message
+ * Kafka specific MP messaging message.
  *
  * @param  kafka record key type
  * @param  kafka record value type
@@ -32,6 +32,11 @@ public class KafkaMessage implements Message> {
 
     private ConsumerRecord consumerRecord;
 
+    /**
+     * Kafka specific MP messaging message.
+     *
+     * @param consumerRecord {@link org.apache.kafka.clients.consumer.ConsumerRecord}
+     */
     public KafkaMessage(ConsumerRecord consumerRecord) {
         this.consumerRecord = consumerRecord;
     }
@@ -43,11 +48,12 @@ public ConsumerRecord getPayload() {
 
     @Override
     public CompletionStage ack() {
-        //TODO: implement acknowledge
+        //implement acknowledge
         return new CompletableFuture<>();
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public  C unwrap(Class unwrapType) {
         if (consumerRecord.getClass().isAssignableFrom(unwrapType)) {
             return (C) consumerRecord;
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
index 7f9f88f1a5d..799ea42022e 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
@@ -16,13 +16,13 @@
 
 package io.helidon.messaging.kafka.connector;
 
+import java.util.function.Consumer;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import java.util.function.Consumer;
-
 /**
- * Reactive streams publisher using {@link java.util.function.Consumer} instead of reactive streams
+ * Reactive streams publisher using {@link java.util.function.Consumer} instead of reactive streams.
  *
  * @param  kafka record key type
  * @param  kafka record value type
@@ -31,6 +31,10 @@ public class SimplePublisher implements Publisher> {
 
     private Consumer>> publisher;
 
+    /**
+     * Create new Reactive Streams publisher using {@link java.util.function.Consumer} instead of reactive streams.
+     * @param publisher {@link java.util.function.Consumer}
+     */
     public SimplePublisher(Consumer>> publisher) {
         this.publisher = publisher;
     }
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
index 0c8189591af..7ee61798223 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
@@ -16,15 +16,6 @@
 
 package io.helidon.messaging.kafka.connector;
 
-import org.eclipse.microprofile.reactive.streams.operators.CompletionRunner;
-import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletionStage;
@@ -36,8 +27,17 @@
 import java.util.function.Supplier;
 import java.util.stream.Collector;
 
+import org.eclipse.microprofile.reactive.streams.operators.CompletionRunner;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
 /**
- * Simple stub to create MicroProfile Reactive Messaging connector without reactive streams
+ * Simple stub to create MicroProfile Reactive Messaging connector without reactive streams.
  *
  * @param  kafka record key type
  * @param  kafka record value type
@@ -46,25 +46,29 @@ public class SimplePublisherBuilder implements PublisherBuilder>> publisher;
 
+    /**
+     * Create new Stub.
+     *
+     * @param publisher {@link java.util.function.Consumer}
+     * @deprecated use helidon reactive streams instead
+     */
+    @Deprecated
     public SimplePublisherBuilder(Consumer>> publisher) {
         this.publisher = publisher;
     }
 
     @Override
     public Publisher> buildRs() {
-        //TODO: Implement ReactiveStreamsEngine instead if simple stub
         return new SimplePublisher(publisher);
     }
 
     @Override
     public CompletionRunner to(Subscriber> subscriber) {
-        //TODO: Gonna need this for outgoing
         throw new UnsupportedOperationException();
     }
 
     @Override
     public  CompletionRunner to(SubscriberBuilder, ? extends R> subscriber) {
-        //TODO: Gonna need this for outgoing
         throw new UnsupportedOperationException();
     }
 
@@ -79,22 +83,26 @@ public  PublisherBuilder map(Function, ? extend
     }
 
     @Override
-    public  PublisherBuilder flatMap(Function, ? extends PublisherBuilder> mapper) {
+    public  PublisherBuilder flatMap(
+            Function, ? extends PublisherBuilder> mapper) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public  PublisherBuilder flatMapRsPublisher(Function, ? extends Publisher> mapper) {
+    public  PublisherBuilder flatMapRsPublisher(
+            Function, ? extends Publisher> mapper) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public  PublisherBuilder flatMapCompletionStage(Function, ? extends CompletionStage> mapper) {
+    public  PublisherBuilder flatMapCompletionStage(
+            Function, ? extends CompletionStage> mapper) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public  PublisherBuilder flatMapIterable(Function, ? extends Iterable> mapper) {
+    public  PublisherBuilder flatMapIterable(
+            Function, ? extends Iterable> mapper) {
         throw new UnsupportedOperationException();
     }
 
@@ -164,7 +172,8 @@ public CompletionRunner cancel() {
     }
 
     @Override
-    public CompletionRunner> reduce(KafkaMessage identity, BinaryOperator> accumulator) {
+    public CompletionRunner> reduce(
+            KafkaMessage identity, BinaryOperator> accumulator) {
         throw new UnsupportedOperationException();
     }
 
@@ -199,12 +208,14 @@ public PublisherBuilder> onErrorResume(Function> onErrorResumeWith(Function>> errorHandler) {
+    public PublisherBuilder> onErrorResumeWith(
+            Function>> errorHandler) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public PublisherBuilder> onErrorResumeWithRsPublisher(Function>> errorHandler) {
+    public PublisherBuilder> onErrorResumeWithRsPublisher(
+            Function>> errorHandler) {
         throw new UnsupportedOperationException();
     }
 
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/package-info.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/package-info.java
new file mode 100644
index 00000000000..4eca2c95b5d
--- /dev/null
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * Microprofile messaging Kafka connector.
+ */
+package io.helidon.messaging.kafka.connector;
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/package-info.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/package-info.java
new file mode 100644
index 00000000000..bf2804f1e62
--- /dev/null
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+/**
+ * Kafka connector.
+ */
+package io.helidon.messaging.kafka;
diff --git a/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
index 964f7454414..279285163ba 100644
--- a/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
+++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/SimpleKafkaTest.java
@@ -65,10 +65,10 @@ static void setUp() {
     @Test
     public void sendAndReceive() throws ExecutionException, InterruptedException, TimeoutException {
         Properties p = new Properties();
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".topic", TEST_TOPIC);
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName());
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".topic", TEST_TOPIC);
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName());
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".topic", TEST_TOPIC);
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_1 + ".key.deserializer", LongDeserializer.class.getName());
@@ -103,10 +103,10 @@ public void queueBySameConsumerGroup() throws ExecutionException, InterruptedExc
         final String TEST_GROUP = "XXX";
 
         Properties p = new Properties();
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".topic", TEST_TOPIC);
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName());
-        p.setProperty("mp.messaging.outcoming." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".topic", TEST_TOPIC);
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".key.serializer", LongSerializer.class.getName());
+        p.setProperty("mp.messaging.outgoing." + TEST_PRODUCER + ".value.serializer", StringSerializer.class.getName());
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".bootstrap.servers", kafkaResource.getKafkaConnectString());
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".topic", TEST_TOPIC);
         p.setProperty("mp.messaging.incoming." + TEST_CONSUMER_2 + ".group.id", TEST_GROUP);

From 51ad1de130e312ab10f4e7255c57cb03ad1845f0 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 23 Nov 2019 17:55:20 +0100
Subject: [PATCH 24/66] Invalid javadoc fix

Signed-off-by: Daniel Kec 
---
 .../messaging/kafka/SimpleKafkaConsumer.java  |   2 +-
 .../messaging/kafka/SimpleKafkaProducer.java  |   6 +-
 .../messaging/channel/IncomingMethod.java     |   2 +-
 .../messaging/channel/InternalProcessor.java  |   2 +-
 .../messaging/channel/MessageUtils.java       |   2 +-
 .../channel/MethodSignatureType.java          | 270 ++++++++++--------
 .../connector/IncomingConnector.java          |   2 +-
 .../connector/OutgoingConnector.java          |   2 +-
 .../reactive/MultiStagesCollector.java        |   4 +-
 9 files changed, 168 insertions(+), 124 deletions(-)

diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
index 39744940ac7..c064abde00a 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
@@ -45,7 +45,7 @@
  * Simple Kafka consumer covering basic use-cases.
  * Configurable by Helidon {@link io.helidon.config.Config Config},
  * For more info about configuration see {@link KafkaConfigProperties}
- * 
    
+ * 
    
  * Usage:
  * 
    {@code
  *   try (SimpleKafkaConsumer c = new SimpleKafkaConsumer<>("test-channel", Config.create())) {
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
index 46a12a5ac62..1f345697974 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaProducer.java
@@ -36,7 +36,7 @@
  * Simple Kafka producer covering basic use-cases.
  * Configurable by Helidon {@link io.helidon.config.Config Config},
  * For more info about configuration see {@link KafkaConfigProperties}.
- * 
    
+ * 
    
  * Usage:
  * 
    {@code new SimpleKafkaProducer("job-done-producer", Config.create())
  *             .produce("Hello world!");
@@ -55,7 +55,7 @@ public class SimpleKafkaProducer implements Closeable {
     private KafkaProducer producer;
 
     /**
-     * Kafka producer created from {@link io.helidon.config.Config config} under kafka->producerId,
+     * Kafka producer created from {@link io.helidon.config.Config config} under kafka-producerId,
      * see configuration {@link KafkaConfigProperties example}.
      *
      * @param producerId key in configuration
@@ -69,7 +69,7 @@ public SimpleKafkaProducer(String producerId, Config config) {
     }
 
     /**
-     * Kafka producer created from {@link io.helidon.config.Config config} under kafka->producerId,
+     * Kafka producer created from {@link io.helidon.config.Config config} under kafka-producerId,
      * see configuration {@link KafkaConfigProperties example}.
      *
      * @param config Helidon {@link io.helidon.config.Config config}
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 2fdaed4690c..4863dd66e41 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -31,7 +31,7 @@
 
 /**
  * Subscriber method with reference to processor method.
- * 
    Example:
+ * 
    Example:
  * 
    {@code
  *     @Incoming("channel-name")
  *     public void exampleIncomingMethod(String msg) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
index 9cd065cb77f..fa4df126d7c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
@@ -31,7 +31,7 @@
 
 /**
  * Processor calling underlined messaging method for every received item.
- * 
    
+ * 
    
  * Example:
  * 
    {@code
  *      @Incoming("channel-one")
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
index 1bd082ca62d..e28f9447d9c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
@@ -41,7 +41,7 @@ private MessageUtils() {
 
     /**
      * Unwrap values to expected types.
-     * 
    
+     * 
    
      * Examples:
      * 
    {@code
      * Message>>
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
index a215b725eeb..59ade5d9211 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
@@ -29,11 +29,14 @@
 public enum MethodSignatureType {
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Processor<Message<I>, Message<O>> method();
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
+     * 
    
+     * 
    Processor<Message<I>, Message<O>> method();
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
      • 
+     * 
    
      */
     PROCESSOR_PROCESSOR_MSG_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -42,11 +45,14 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Processor<I, O> method();
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    
+     * 
    Processor<I, O> method();
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PROCESSOR_PAYL_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -54,11 +60,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: Assembly time -
-     * 
    ProcessorBuilder<Message<I>, Message<O>> method();
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
+     * 
    ProcessorBuilder<Message<I>, Message<O>> method();
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, MANUAL
      • 
+     * 
    
      */
     PROCESSOR_PROCESSOR_BUILDER_MSG_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -67,11 +75,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: Assembly time -
-     * 
    ProcessorBuilder<I, O> method();
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    ProcessorBuilder<I, O> method();
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PROCESSOR_BUILDER_PAYL_2_VOID(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -79,12 +89,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Publisher<Message<O>> method(Publisher<Message<I>> pub);
    
-     * 
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    Publisher<Message<O>> method(Publisher<Message<I>> pub);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_MSG_2_PUBLISHER_MSG(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -93,12 +104,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Publisher<O> method(Publisher<I> pub);
    
-     * 
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    Publisher<O> method(Publisher<I> pub);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_PAYL_2_PUBLISHER_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -106,12 +118,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    PublisherBuilder<Message<O>> method(PublisherBuilder<Message<I>> pub);
    
-     * 
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    PublisherBuilder<Message<O>> method(PublisherBuilder<Message<I>> pub);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_BUILDER_MSG_2_PUBLISHER_BUILDER_MSG(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -120,12 +133,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    PublisherBuilder<O> method(PublisherBuilder<I> pub);
    
-     * 
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    PublisherBuilder<O> method(PublisherBuilder<I> pub);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PUBLISHER_BUILDER_PAYL(true, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -133,11 +147,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    Publisher<Message<O>> method(Message<I> msg);
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    Publisher<Message<O>> method(Message<I> msg);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -146,11 +162,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    Publisher<O> method(I payload);
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    Publisher<O> method(I payload);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -158,11 +176,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    PublisherBuilder<Message<O>> method(Message<I> msg);
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    PublisherBuilder<Message<O>> method(Message<I> msg);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_BUILDER_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -171,11 +191,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    PublisherBuilder<O> method(I payload);
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    PublisherBuilder<O> method(I payload);
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PUBLISHER_BUILDER_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -183,11 +205,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    Message<O> method(Message<I> msg)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    Message<O> method(Message<I> msg)
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -196,11 +220,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
      * 
    O method(I payload)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -208,11 +234,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    CompletionStage<Message<O>> method(Message<I> msg)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
+     * 
    CompletionStage<Message<O>> method(Message<I> msg)
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_COMPL_STAGE_MSG_2_MSG(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -221,11 +249,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Processor method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    CompletionStage<O> method(I payload)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING
+     * 
    CompletionStage<O> method(I payload)
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     * 
    
      */
     PROCESSOR_COMPL_STAGE_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -235,11 +265,13 @@ public enum MethodSignatureType {
 
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Subscriber<Message<I>> method()
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     * 
    Subscriber<Message<I>> method()
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_SUBSCRIBER_MSG_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -250,11 +282,13 @@ public enum MethodSignatureType {
 
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Subscriber<I> method()
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
+     * 
    Subscriber<I> method()
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_SUBSCRIBER_PAYL_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -263,11 +297,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    SubscriberBuilder<Message<I>> method()
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     * 
    SubscriberBuilder<Message<I>> method()
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -277,11 +313,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    SubscriberBuilder<I> method()
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
+     * 
    SubscriberBuilder<I> method()
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID(true, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -290,11 +328,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
      * 
    void method(I payload)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_VOID_2_PAYL(false, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -303,11 +343,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    CompletionStage<?> method(Message<I> msg)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
+     * 
    CompletionStage<?> method(Message<I> msg)
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, MANUAL, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_COMPLETION_STAGE_2_MSG(false, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -317,11 +359,13 @@ public enum MethodSignatureType {
     ),
     /**
      * Subscriber method signature type.
-     * 
    
+     * 
    
      * Invoke at: every incoming
-     * 
    CompletionStage<?> method(I payload)
    
-     * 
  • Default acknowledgment strategy: PRE_PROCESSING
-     * 
  • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
+     * 
    CompletionStage<?> method(I payload)
    
+     * 
      
+     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      • 
+     * 
    
      */
     INCOMING_COMPLETION_STAGE_2_PAYL(false, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
@@ -331,42 +375,42 @@ public enum MethodSignatureType {
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Publisher<Message<U>> method()
    
+     * 
    Publisher<Message<U<< method()
    
      */
     OUTGOING_PUBLISHER_MSG_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    Publisher<U> method()
    
+     * 
    Publisher<U< method()
    
      */
     OUTGOING_PUBLISHER_PAYL_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    PublisherBuilder<Message<U>> method()
    
+     * 
    PublisherBuilder<Message<U<< method()
    
      */
     OUTGOING_PUBLISHER_BUILDER_MSG_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: assembly time
-     * 
    PublisherBuilder<U> method()
    
+     * 
    PublisherBuilder<U< method()
    
      */
     OUTGOING_PUBLISHER_BUILDER_PAYL_2_VOID(true, null),
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: Each request made by subscriber
-     * 
    Message<U> method()
    
-     * 
    
+     * 
    Message<U< method()
    
+     * 
    
      * Produces an infinite stream of Message associated with the
      * channel channel. The result is a CompletionStage. The method should not be
      * called by the reactive messaging implementation until the CompletionStage
@@ -376,10 +420,10 @@ public enum MethodSignatureType {
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: Each request made by subscriber
      * 
    U method()
    
-     * 
    
+     * 
    
      * Produces an infinite stream of Message associated with the
      * channel channel. The result is a CompletionStage. The method should not be
      * called by the reactive messaging implementation until the CompletionStage
@@ -389,10 +433,10 @@ public enum MethodSignatureType {
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: Each request made by subscriber
-     * 
    CompletionStage<Message<U>> method()
    
-     * 
    
+     * 
    CompletionStage<Message<U<< method()
    
+     * 
    
      * Produces an infinite stream of Message associated with the
      * channel channel. The result is a CompletionStage. The method should not be
      * called by the reactive messaging implementation until the CompletionStage
@@ -402,10 +446,10 @@ public enum MethodSignatureType {
 
     /**
      * Publisher method signature type.
-     * 
    
+     * 
    
      * Invoke at: Each request made by subscriber
-     * 
    CompletionStage<U> method()
    
-     * 
    
+     * 
    CompletionStage<U< method()
    
+     * 
    
      * Produces an infinite stream of Message associated with the
      * channel channel. The result is a CompletionStage. The method should not be
      * called by the reactive messaging implementation until the CompletionStage
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
index 83966224f8e..54fc7fdc172 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
@@ -28,7 +28,7 @@
 
 /**
  * Connector as defined in configuration.
- * 
    
+ * 
    
  * 
    {@code
  * mp.messaging.incoming.[channel-name].connector=[connector-name]
  * ...
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
index 29caec3a60f..eb3fe2c265c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
@@ -29,7 +29,7 @@
 
 /**
  * Connector as defined in configuration.
- * 
    
+ * 
    
  * 
    {@code
  * mp.messaging.incoming.[channel-name].connector=[connector-name]
  * ...
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
index 3243372d418..a62fb277e69 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
@@ -194,7 +194,7 @@  CompletionStage getCompletionStage() {
 
     /**
      * Return {@link org.reactivestreams.Processor} wrapping all processor stages from processor builder.
-     * 
    See example:
+     * 
    See example:
      * 
    {@code
      *   Processor processor = ReactiveStreams.builder()
      *       .map(i -> i + 1)
@@ -214,7 +214,7 @@  Processor getProcessor() {
 
     /**
      * Returns {@link org.reactivestreams.Publisher} made from supplied stages.
-     * 
    See example:
+     * 
    See example:
      * 
    {@code
      *   ReactiveStreams
      *      .of("10", "20", "30")

From 069e13d5e621b1b0849ee783ecb0a9bdbb72be14 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 25 Nov 2019 18:36:01 +0100
Subject: [PATCH 25/66] Partial ack impl

Signed-off-by: Daniel Kec 
---
 bom/pom.xml                                   |   5 +
 messaging/kafka/pom.xml                       |  78 ++++--
 .../messaging/kafka/SimpleKafkaConsumer.java  |  71 +++++-
 .../connector/KafkaConnectorFactory.java      |   2 +-
 .../kafka/connector/KafkaMessage.java         |   9 +-
 .../kafka/connector/SimplePublisher.java      |   1 +
 .../connector/SimplePublisherBuilder.java     | 233 ------------------
 .../kafka}/kafka/KafkaCdiExtensionTest.java   | 121 ++++++---
 .../kafka}/kafka/KafkaConsumingBean.java      |  20 +-
 .../kafka/KafkaProducingConsumingBean.java    |   2 +-
 .../src/test/resources/application.yaml       |   0
 .../src/test/resources/logging.properties     |  14 +-
 microprofile/messaging/pom.xml                |  44 ----
 .../messaging/channel/AbstractMethod.java     |  22 +-
 .../messaging/channel/IncomingMethod.java     |   3 +-
 .../messaging/channel/InternalProcessor.java  |  30 ++-
 .../messaging/channel/InternalSubscriber.java |  61 +++--
 .../messaging/channel/MessageUtils.java       |  29 ++-
 .../channel/MethodSignatureType.java          |   9 +-
 .../messaging/channel/OutgoingMethod.java     |   1 +
 .../messaging/channel/ProcessorMethod.java    |   1 +
 .../connector/IncomingConnector.java          |   2 +-
 .../connector/OutgoingConnector.java          |   2 +-
 .../messaging/AbstractCDITest.java            |  52 ++--
 ...eTestBean.java => AssertableTestBean.java} |  10 +-
 .../channel/MethodSignatureResolverTest.java  |   5 +-
 .../connector/AdHocConfigBuilderTest.java     |  16 +-
 .../messaging/inner/InnerChannelTest.java     |  69 +-----
 .../inner/ack/IncomingManualAckBean.java      |  71 ++++++
 .../IncomingPostProcessExplicitAckBean.java   |  63 +++++
 .../IncomingPostProcessImplicitAckBean.java   |  61 +++++
 .../inner/ack/IncomingPreProcessAckBean.java  |  68 +++++
 ...alAckBean.java => InvalidAckStrategy.java} |  29 +--
 .../inner/ack/ProcessorManualAckBean.java     |  75 ++++++
 .../ProcessorPostProcessExplicitAckBean.java  |  69 ++++++
 ... ProcessorPostProcessImplicitAckBean.java} |  29 ++-
 .../inner/ack/ProcessorPreProcessAckBean.java |  74 ++++++
 .../PublisherBuilderTransformerV1Bean.java    |   4 +-
 .../PublisherBuilderTransformerV2Bean.java    |   4 +-
 .../PublisherFromPublisherV1Bean.java         |   4 +-
 .../PublisherFromPublisherV2Bean.java         |   4 +-
 .../PublisherPayloadV1Bean.java               |   4 +-
 .../PublisherPayloadV3Bean.java               |   4 +-
 .../PublisherPayloadV4Bean.java               |   4 +-
 .../PublisherPayloadV5Bean.java               |   4 +-
 .../PublisherPayloadV6Bean.java               |   4 +-
 .../PublisherProcessorV1Bean.java             |   2 +-
 .../PublisherProcessorV2Bean.java             |   2 +-
 .../PublisherProcessorV3Bean.java             |   2 +-
 .../PublisherProcessorV4Bean.java             |   2 +-
 .../PublisherSubscriberBuilderV1Bean.java     |   4 +-
 .../PublisherSubscriberBuilderV2Bean.java     |   4 +-
 .../PublisherSubscriberV1Bean.java            |   4 +-
 .../PublisherSubscriberV2Bean.java            |   4 +-
 .../SubscriberPublMsgToMsgRetComplBean.java   |  60 +++++
 ...scriberPublMsgToMsgRetComplStringBean.java |  63 +++++
 .../SubscriberPublMsgToPaylBean.java          |  57 +++++
 ...criberPublMsgToPaylRetComplStringBean.java |  62 +++++
 ...bscriberPublMsgToPaylRetComplVoidBean.java |  60 +++++
 .../SubscriberPublMsgToPaylRetPaylBean.java   |  58 +++++
 ...ubscriberPublMsgToSubsBuilderPaylBean.java |  59 +++++
 .../SubscriberPublMsgToSubsPaylBean.java      |  60 +++++
 .../subscriber/SubscriberPublToSubsBean.java  |  60 +++++
 .../SubscriberPublToSubsBuilderBean.java      |  59 +++++
 microprofile/tests/tck/tck-messaging/pom.xml  | 116 +++++++++
 65 files changed, 1667 insertions(+), 558 deletions(-)
 delete mode 100644 messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
 rename {microprofile/messaging/src/test/java/io/helidon/microprofile/messaging => messaging/kafka/src/test/java/io/helidon/messaging/kafka}/kafka/KafkaCdiExtensionTest.java (63%)
 rename {microprofile/messaging/src/test/java/io/helidon/microprofile/messaging => messaging/kafka/src/test/java/io/helidon/messaging/kafka}/kafka/KafkaConsumingBean.java (72%)
 rename {microprofile/messaging/src/test/java/io/helidon/microprofile/messaging => messaging/kafka/src/test/java/io/helidon/messaging/kafka}/kafka/KafkaProducingConsumingBean.java (97%)
 rename {microprofile/messaging => messaging/kafka}/src/test/resources/application.yaml (100%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/{CompletableTestBean.java => AssertableTestBean.java} (74%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ManualAckBean.java => InvalidAckStrategy.java} (60%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ChainWithPayloadAckBean.java => ProcessorPostProcessImplicitAckBean.java} (60%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherBuilderTransformerV1Bean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherBuilderTransformerV2Bean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherFromPublisherV1Bean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherFromPublisherV2Bean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherPayloadV1Bean.java (91%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherPayloadV3Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherPayloadV4Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherPayloadV5Bean.java (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherPayloadV6Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherProcessorV1Bean.java (97%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherProcessorV2Bean.java (97%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherProcessorV3Bean.java (97%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherProcessorV4Bean.java (97%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherSubscriberBuilderV1Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherSubscriberBuilderV2Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherSubscriberV1Bean.java (92%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/{ => publisher}/PublisherSubscriberV2Bean.java (92%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplStringBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplStringBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplVoidBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetPaylBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsBuilderPaylBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsPaylBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBuilderBean.java

diff --git a/bom/pom.xml b/bom/pom.xml
index 7940cf898ed..5ef324ae42d 100644
--- a/bom/pom.xml
+++ b/bom/pom.xml
@@ -441,6 +441,11 @@
                 helidon-microprofile-access-log
                 ${helidon.version}
             
+            
+                io.helidon.microprofile
+                helidon-microprofile-reactive-streams
+                ${helidon.version}
+            
             
             
                 io.helidon.metrics
diff --git a/messaging/kafka/pom.xml b/messaging/kafka/pom.xml
index 954e6a0c0b6..f917bd8e6f7 100644
--- a/messaging/kafka/pom.xml
+++ b/messaging/kafka/pom.xml
@@ -44,55 +44,69 @@
         
             javax.enterprise
             cdi-api
-            2.0
             provided
         
+        
+            
+            javax.activation
+            javax.activation-api
+            provided
+        
+
         
             org.eclipse.microprofile.reactive.messaging
             microprofile-reactive-messaging-api
             1.0
         
+
+        
+            io.helidon.microprofile.config
+            helidon-microprofile-config
+        
+        
+            io.helidon.microprofile.config
+            helidon-microprofile-config-cdi
+        
         
-            org.eclipse.microprofile.reactive-streams-operators
-            microprofile-reactive-streams-operators-core
-            1.0.1
+            io.helidon.microprofile.server
+            helidon-microprofile-server
         
         
-            io.helidon.config
-            helidon-config-yaml
+            io.helidon.microprofile
+            helidon-microprofile-reactive-streams
             1.3.2-SNAPSHOT
         
         
-            io.helidon.microprofile.config
-            helidon-microprofile-config
+            io.helidon.microprofile
+            helidon-microprofile-messaging
             1.3.2-SNAPSHOT
         
         
-            org.apache.kafka
-            kafka_2.11
-            2.3.0
+            org.jboss.weld.se
+            weld-se-core
         
         
-            org.apache.kafka
-            kafka-clients
-            2.3.0
+            org.slf4j
+            slf4j-api
         
         
-            org.junit.jupiter
-            junit-jupiter-api
-            5.6.0-M1
-            test
+            
+            org.slf4j
+            slf4j-jdk14
         
         
-            org.junit.jupiter
-            junit-jupiter
-            5.6.0-M1
+            io.helidon.microprofile.bundles
+            internal-test-libs
             test
         
         
-            com.salesforce.kafka.test
-            kafka-junit5
-            3.1.1
+            org.jboss.weld
+            weld-junit5
             test
         
         
@@ -102,6 +116,22 @@
             1.7.28
             test
         
+        
+            com.salesforce.kafka.test
+            kafka-junit5
+            3.1.1
+            test
+        
+        
+            org.apache.kafka
+            kafka-clients
+            2.3.0
+        
+        
+            org.apache.kafka
+            kafka_2.11
+            2.3.0
+        
     
 
     
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
index c064abde00a..d5b26acbed6 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
@@ -23,6 +23,10 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -30,16 +34,23 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import io.helidon.common.context.Context;
+import io.helidon.common.context.Contexts;
 import io.helidon.config.Config;
 import io.helidon.messaging.kafka.connector.KafkaMessage;
-import io.helidon.messaging.kafka.connector.SimplePublisherBuilder;
+import io.helidon.messaging.kafka.connector.SimplePublisher;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.ConsumerRecords;
 import org.apache.kafka.clients.consumer.KafkaConsumer;
 import org.apache.kafka.common.errors.WakeupException;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Subscription;
 
 /**
  * Simple Kafka consumer covering basic use-cases.
@@ -71,6 +82,9 @@ public class SimpleKafkaConsumer implements Closeable {
     private List topicNameList;
     private KafkaConsumer consumer;
 
+    private ConcurrentLinkedDeque> recordBuffer = new ConcurrentLinkedDeque<>();
+    private CopyOnWriteArrayList> ackFutures = new CopyOnWriteArrayList<>();
+
     /**
      * Kafka consumer created from {@link io.helidon.config.Config config}
      * see configuration {@link KafkaConfigProperties example}.
@@ -171,21 +185,33 @@ public Future consumeAsync(ExecutorService executorService, List cust
      * Create publisher builder.
      *
      * @param executorService {@link java.util.concurrent.ExecutorService}
-     * @return {@link io.helidon.messaging.kafka.connector.SimplePublisherBuilder}
+     * @return {@link org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder}
      */
-    public SimplePublisherBuilder createPublisherBuilder(ExecutorService executorService) {
+    public PublisherBuilder> createPushPublisherBuilder(ExecutorService executorService) {
         validateConsumer();
         this.externalExecutorService = executorService;
-        return new SimplePublisherBuilder<>(subscriber -> {
+        return ReactiveStreams.fromPublisher(new SimplePublisher(subscriber -> {
+            subscriber.onSubscribe(new Subscription() {
+                @Override
+                public void request(long n) {
+                    LOGGER.log(Level.FINE, "Pushing Kafka consumer doesn't support requests.");
+                }
+
+                @Override
+                public void cancel() {
+                    SimpleKafkaConsumer.this.close();
+                }
+            });
             externalExecutorService.submit(() -> {
                 consumer.subscribe(topicNameList, partitionsAssignedLatch);
                 try {
                     while (!closed.get()) {
-                        ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(5));
-                        consumerRecords.forEach(cr -> {
-                            KafkaMessage kafkaMessage = new KafkaMessage<>(cr);
-                            executorService.execute(() -> subscriber.onNext(kafkaMessage));
-                        });
+                        waitForAcksAndPoll();
+                        if (recordBuffer.isEmpty()) continue;
+                        ConsumerRecord cr = recordBuffer.poll();
+                        KafkaMessage kafkaMessage = new KafkaMessage<>(cr);
+                        ackFutures.add(kafkaMessage.getAckFuture());
+                        runInNewContext(() -> subscriber.onNext(kafkaMessage));
                     }
                 } catch (WakeupException ex) {
                     if (!closed.get()) {
@@ -196,7 +222,21 @@ public SimplePublisherBuilder createPublisherBuilder(ExecutorService execu
                     consumer.close();
                 }
             });
-        });
+        }));
+    }
+
+    private void waitForAcksAndPoll() {
+        if (recordBuffer.isEmpty()) {
+            try {
+                if (!ackFutures.isEmpty()) {
+                    CompletableFuture.allOf(ackFutures.toArray(new CompletableFuture[0])).get();
+                    consumer.commitSync();
+                }
+                consumer.poll(Duration.ofSeconds(1)).forEach(recordBuffer::add);
+            } catch (InterruptedException | ExecutionException e) {
+                LOGGER.log(Level.SEVERE, "Error when waiting for all polled records acknowledgements.", e);
+            }
+        }
     }
 
     private void validateConsumer() {
@@ -248,4 +288,15 @@ protected String getOrGenerateGroupId(String customGroupId) {
                         .orElse(UUID.randomUUID().toString()));
     }
 
+    //Move to messaging incoming connector
+    private void runInNewContext(Runnable runnable) {
+        Context parentContext = Context.create();
+        Context context = Context
+                .builder()
+                .parent(parentContext)
+                .id(String.format("%s:message-%s", parentContext.id(), UUID.randomUUID().toString()))
+                .build();
+        Contexts.runInContext(context, runnable);
+    }
+
 }
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
index 133330a949a..7b54d365806 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaConnectorFactory.java
@@ -66,7 +66,7 @@ public PublisherBuilder> getPublisherBuilder(org.eclipse.mi
         Config helidonConfig = ((MpConfig) config).helidonConfig();
         SimpleKafkaConsumer simpleKafkaConsumer = new SimpleKafkaConsumer<>(helidonConfig);
         consumers.add(simpleKafkaConsumer);
-        return simpleKafkaConsumer.createPublisherBuilder(getThreadPoolSupplier(helidonConfig).get());
+        return simpleKafkaConsumer.createPushPublisherBuilder(getThreadPoolSupplier(helidonConfig).get());
     }
 
     private ThreadPoolSupplier getThreadPoolSupplier(Config config) {
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
index b106181370e..c0da9843c1e 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/KafkaMessage.java
@@ -31,6 +31,7 @@
 public class KafkaMessage implements Message> {
 
     private ConsumerRecord consumerRecord;
+    private CompletableFuture ackFuture = new CompletableFuture<>();
 
     /**
      * Kafka specific MP messaging message.
@@ -46,10 +47,14 @@ public ConsumerRecord getPayload() {
         return consumerRecord;
     }
 
+    public CompletableFuture getAckFuture() {
+        return ackFuture;
+    }
+
     @Override
     public CompletionStage ack() {
-        //implement acknowledge
-        return new CompletableFuture<>();
+        ackFuture.complete(null);
+        return ackFuture;
     }
 
     @Override
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
index 799ea42022e..8e442f710cc 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisher.java
@@ -33,6 +33,7 @@ public class SimplePublisher implements Publisher> {
 
     /**
      * Create new Reactive Streams publisher using {@link java.util.function.Consumer} instead of reactive streams.
+     *
      * @param publisher {@link java.util.function.Consumer}
      */
     public SimplePublisher(Consumer>> publisher) {
diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
deleted file mode 100644
index 7ee61798223..00000000000
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/connector/SimplePublisherBuilder.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.messaging.kafka.connector;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.CompletionStage;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-import java.util.stream.Collector;
-
-import org.eclipse.microprofile.reactive.streams.operators.CompletionRunner;
-import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
-/**
- * Simple stub to create MicroProfile Reactive Messaging connector without reactive streams.
- *
- * @param  kafka record key type
- * @param  kafka record value type
- */
-public class SimplePublisherBuilder implements PublisherBuilder> {
-
-    private Consumer>> publisher;
-
-    /**
-     * Create new Stub.
-     *
-     * @param publisher {@link java.util.function.Consumer}
-     * @deprecated use helidon reactive streams instead
-     */
-    @Deprecated
-    public SimplePublisherBuilder(Consumer>> publisher) {
-        this.publisher = publisher;
-    }
-
-    @Override
-    public Publisher> buildRs() {
-        return new SimplePublisher(publisher);
-    }
-
-    @Override
-    public CompletionRunner to(Subscriber> subscriber) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  CompletionRunner to(SubscriberBuilder, ? extends R> subscriber) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public Publisher> buildRs(ReactiveStreamsEngine engine) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder map(Function, ? extends R> mapper) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder flatMap(
-            Function, ? extends PublisherBuilder> mapper) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder flatMapRsPublisher(
-            Function, ? extends Publisher> mapper) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder flatMapCompletionStage(
-            Function, ? extends CompletionStage> mapper) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder flatMapIterable(
-            Function, ? extends Iterable> mapper) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> filter(Predicate> predicate) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> distinct() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> limit(long maxSize) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> skip(long n) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> takeWhile(Predicate> predicate) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> dropWhile(Predicate> predicate) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> peek(Consumer> consumer) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onError(Consumer errorHandler) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onTerminate(Runnable action) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onComplete(Runnable action) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner forEach(Consumer> action) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner ignore() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner cancel() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner> reduce(
-            KafkaMessage identity, BinaryOperator> accumulator) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner>> reduce(BinaryOperator> accumulator) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner>> findFirst() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  CompletionRunner collect(Collector, A, R> collector) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  CompletionRunner collect(Supplier supplier, BiConsumer> accumulator) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public CompletionRunner>> toList() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onErrorResume(Function> errorHandler) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onErrorResumeWith(
-            Function>> errorHandler) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public PublisherBuilder> onErrorResumeWithRsPublisher(
-            Function>> errorHandler) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder via(ProcessorBuilder, ? extends R> processor) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public  PublisherBuilder via(Processor, ? extends R> processor) {
-        throw new UnsupportedOperationException();
-    }
-
-
-}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaCdiExtensionTest.java
similarity index 63%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
rename to messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaCdiExtensionTest.java
index c56a4713efe..e7e5170c580 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaCdiExtensionTest.java
+++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaCdiExtensionTest.java
@@ -15,48 +15,73 @@
  *
  */
 
-package io.helidon.microprofile.messaging.kafka;
+package io.helidon.messaging.kafka.kafka;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
+
+import javax.enterprise.inject.se.SeContainer;
+import javax.enterprise.inject.se.SeContainerInitializer;
 
-import com.salesforce.kafka.test.junit5.SharedKafkaTestResource;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 import io.helidon.messaging.kafka.SimpleKafkaProducer;
 import io.helidon.messaging.kafka.connector.KafkaConnectorFactory;
-import io.helidon.microprofile.messaging.AbstractCDITest;
-import io.helidon.microprofile.messaging.kafka.KafkaConsumingBean;
+import io.helidon.microprofile.config.MpConfig;
+import io.helidon.microprofile.config.MpConfigProviderResolver;
+import io.helidon.microprofile.messaging.MessagingCdiExtension;
+import io.helidon.microprofile.server.Server;
+
+import static io.helidon.common.CollectionsHelper.mapOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import com.salesforce.kafka.test.junit5.SharedKafkaTestResource;
 import org.apache.kafka.clients.producer.RecordMetadata;
 import org.apache.kafka.common.serialization.LongDeserializer;
 import org.apache.kafka.common.serialization.LongSerializer;
 import org.apache.kafka.common.serialization.StringDeserializer;
 import org.apache.kafka.common.serialization.StringSerializer;
+import org.eclipse.microprofile.reactive.messaging.spi.Connector;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+public class KafkaCdiExtensionTest {
 
-import static io.helidon.common.CollectionsHelper.mapOf;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
+    protected SeContainer cdiContainer;
 
-public class KafkaCdiExtensionTest extends AbstractCDITest {
+    protected static final Connector KAFKA_CONNECTOR_LITERAL = new Connector() {
 
+        @Override
+        public Class annotationType() {
+            return Connector.class;
+        }
+
+        @Override
+        public String value() {
+            return KafkaConnectorFactory.CONNECTOR_NAME;
+        }
+    };
 
     @RegisterExtension
     public static final SharedKafkaTestResource kafkaResource = new SharedKafkaTestResource();
     public static final String TEST_TOPIC = "graph-done";
     public static final String TEST_MESSAGE = "this is first test message";
 
-    @Override
     protected Map cdiConfig() {
         Map p = new HashMap<>();
         p.putAll(mapOf(
@@ -75,21 +100,22 @@ protected Map cdiConfig() {
         return p;
     }
 
-    @Override
-    protected void cdiBeanClasses(Set> classes) {
-        classes.add(KafkaConnectorFactory.class);
-        classes.add(KafkaConsumingBean.class);
-    }
-
     @BeforeAll
-    public static void prepareTopics() {
+    static void prepareTopics() {
         kafkaResource.getKafkaTestUtils().createTopic(TEST_TOPIC, 10, (short) 1);
     }
 
     @BeforeEach
-    @Override
-    public void setUp() {
-        super.setUp();
+    void setUp() {
+        Set> classes = new HashSet<>();
+        classes.add(KafkaConnectorFactory.class);
+        classes.add(KafkaConsumingBean.class);
+        classes.add(MessagingCdiExtension.class);
+
+        Map p = new HashMap<>(cdiConfig());
+        System.out.println("Starting container ...");
+        cdiContainer = startCdiContainer(p, classes);
+        assertTrue(cdiContainer.isRunning());
         //Wait till consumers are ready
         forEachBean(KafkaConnectorFactory.class, KAFKA_CONNECTOR_LITERAL, b -> b.getConsumers().forEach(c -> {
             try {
@@ -100,21 +126,28 @@ public void setUp() {
         }));
     }
 
+    @AfterEach
+    public void tearDown() {
+        if (cdiContainer != null) {
+            cdiContainer.close();
+        }
+    }
+
     @Test
     void incomingKafkaTest() throws InterruptedException {
         // Producer
         Map p = mapOf(
-                "mp.messaging.outcoming.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString(),
-                "mp.messaging.outcoming.test-channel.topic", TEST_TOPIC,
-                "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName(),
-                "mp.messaging.outcoming.test-channel.value.serializer", StringSerializer.class.getName()
+                "mp.messaging.outgoing.test-channel.bootstrap.servers", kafkaResource.getKafkaConnectString(),
+                "mp.messaging.outgoing.test-channel.topic", TEST_TOPIC,
+                "mp.messaging.outgoing.test-channel.key.serializer", LongSerializer.class.getName(),
+                "mp.messaging.outgoing.test-channel.value.serializer", StringSerializer.class.getName()
         );
 
         Config config = Config.builder()
                 .sources(ConfigSources.create(p))
                 .build();
 
-        SimpleKafkaProducer producer = new SimpleKafkaProducer<>(config.get("mp.messaging.outcoming.test-channel"));
+        SimpleKafkaProducer producer = new SimpleKafkaProducer<>(config.get("mp.messaging.outgoing.test-channel"));
         List> producerFutures = new ArrayList<>(KafkaConsumingBean.TEST_DATA.size());
 
         //Send all test messages(async send means order is not guaranteed)
@@ -135,4 +168,26 @@ void incomingKafkaTest() throws InterruptedException {
                         + KafkaConsumingBean.testChannelLatch.getCount());
         producer.close();
     }
+
+    private  void forEachBean(Class beanType, Annotation annotation, Consumer consumer) {
+        cdiContainer.select(beanType, annotation).stream().forEach(consumer);
+    }
+
+    private static SeContainer startCdiContainer(Map p, Set> beanClasses) {
+        Config config = Config.builder()
+                .sources(ConfigSources.create(p))
+                .build();
+
+        final Server.Builder builder = Server.builder();
+        assertNotNull(builder);
+        builder.config(config);
+        MpConfigProviderResolver.instance()
+                .registerConfig(MpConfig.builder()
+                                .config(config).build(),
+                        Thread.currentThread().getContextClassLoader());
+        final SeContainerInitializer initializer = SeContainerInitializer.newInstance();
+        assertNotNull(initializer);
+        initializer.addBeanClasses(beanClasses.toArray(new Class[0]));
+        return initializer.initialize();
+    }
 }
\ No newline at end of file
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaConsumingBean.java
similarity index 72%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
rename to messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaConsumingBean.java
index f2d2c04face..c59b11eca9d 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaConsumingBean.java
+++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaConsumingBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.kafka;
+package io.helidon.messaging.kafka.kafka;
 
 import java.util.Arrays;
 import java.util.HashSet;
@@ -29,26 +29,28 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 
 @ApplicationScoped
 public class KafkaConsumingBean {
 
-    public static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
-    //Two methods -> two consumers of same topic means twice as much received messages
-    public static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() * 2);
+    static Set TEST_DATA = new HashSet<>(Arrays.asList("test1", "test2", "test3"));
+    static CountDownLatch testChannelLatch = new CountDownLatch(TEST_DATA.size() /* 2*/);
 
     @Incoming("test-channel-1")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
     public CompletionStage receiveMPMessage(Message> msg) {
         assertTrue(TEST_DATA.contains(msg.getPayload().value()));
         testChannelLatch.countDown();
+        msg.ack();
         return CompletableFuture.completedFuture(null);
     }
 
-    @Incoming("test-channel-2")
-    public void receiveKafkaConsumerRecord(ConsumerRecord msg) {
-        assertTrue(TEST_DATA.contains(msg.value()));
-        testChannelLatch.countDown();
-    }
+//    @Incoming("test-channel-2")
+//    public void receiveKafkaConsumerRecord(ConsumerRecord msg) {
+//        assertTrue(TEST_DATA.contains(msg.value()));
+//        testChannelLatch.countDown();
+//    }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaProducingConsumingBean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java
rename to messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaProducingConsumingBean.java
index b8230483042..d6c9544c49e 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/kafka/KafkaProducingConsumingBean.java
+++ b/messaging/kafka/src/test/java/io/helidon/messaging/kafka/kafka/KafkaProducingConsumingBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.kafka;
+package io.helidon.messaging.kafka.kafka;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/resources/application.yaml b/messaging/kafka/src/test/resources/application.yaml
similarity index 100%
rename from microprofile/messaging/src/test/resources/application.yaml
rename to messaging/kafka/src/test/resources/application.yaml
diff --git a/messaging/kafka/src/test/resources/logging.properties b/messaging/kafka/src/test/resources/logging.properties
index 6143051b021..fba4a4e5802 100644
--- a/messaging/kafka/src/test/resources/logging.properties
+++ b/messaging/kafka/src/test/resources/logging.properties
@@ -20,12 +20,12 @@ java.util.logging.ConsoleHandler.level=INFO
 .level=INFO
 
 # Known issue with meta.properties in embedded kafka server
-kafka.server.BrokerMetadataCheckpoint.level=SEVERE
+#kafka.server.BrokerMetadataCheckpoint.level=SEVERE
 # Hide whole configuration print-out
-org.apache.kafka.clients.producer.ProducerConfig.level=WARNING
-org.apache.kafka.clients.consumer.ConsumerConfig.level=WARNING
+#org.apache.kafka.clients.producer.ProducerConfig.level=WARNING
+#org.apache.kafka.clients.consumer.ConsumerConfig.level=WARNING
 # Embedded kafka server exhausting logs
-kafka.level=WARNING
-org.apache.kafka.level=WARNING
-org.apache.zookeeper.level=SEVERE
-com.salesforce.kafka.level=SEVERE
+#kafka.level=WARNING
+#org.apache.kafka.level=WARNING
+#org.apache.zookeeper.level=SEVERE
+#com.salesforce.kafka.level=SEVERE
diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml
index 7027a43eea5..426f13a7632 100644
--- a/microprofile/messaging/pom.xml
+++ b/microprofile/messaging/pom.xml
@@ -32,29 +32,11 @@
     
 
     
-        
-            javax.enterprise
-            cdi-api
-            provided
-        
-        
-            
-            javax.activation
-            javax.activation-api
-            provided
-        
-
         
             org.eclipse.microprofile.reactive.messaging
             microprofile-reactive-messaging-api
             1.0
         
-
         
             io.helidon.microprofile.config
             helidon-microprofile-config
@@ -70,26 +52,6 @@
         
             io.helidon.microprofile
             helidon-microprofile-reactive-streams
-            1.3.2-SNAPSHOT
-        
-        
-            org.jboss.weld.se
-            weld-se-core
-        
-        
-            org.slf4j
-            slf4j-api
-        
-        
-            
-            org.slf4j
-            slf4j-jdk14
-        
-        
-            io.helidon.messaging.connectors
-            kafka-connector
-            1.3.2-SNAPSHOT
-            test
         
         
             io.helidon.microprofile.bundles
@@ -101,12 +63,6 @@
             weld-junit5
             test
         
-        
-            com.salesforce.kafka.test
-            kafka-junit5
-            3.1.1
-            test
-        
         
             
             org.slf4j
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
index fb974b19434..0b5823f1b4b 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/AbstractMethod.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.messaging.channel;
 
 import java.lang.reflect.Method;
+import java.util.Optional;
 
 import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
@@ -40,14 +41,23 @@ abstract class AbstractMethod {
 
     AbstractMethod(Method method) {
         this.method = method;
+        type = MethodSignatureResolver.create(method).resolve();
+        resolveAckStrategy();
     }
 
-    abstract void validate();
+    void validate() {
+        Optional.ofNullable(method.getAnnotation(Acknowledgment.class))
+                .map(Acknowledgment::value)
+                .filter(s -> !type.getSupportedAckStrategies().contains(s))
+                .ifPresent(strategy -> {
+                    throw new RuntimeException(
+                            String.format("Acknowledgment strategy %s is not supported for method signature: %s",
+                                    strategy, type));
+                });
+    }
 
     public void init(BeanManager beanManager, Config config) {
         this.beanInstance = ChannelRouter.lookup(bean, beanManager);
-        type = MethodSignatureResolver.create(method).resolve();
-        resolveAckStrategy();
     }
 
     public Method getMethod() {
@@ -95,7 +105,9 @@ public Acknowledgment.Strategy getAckStrategy() {
     }
 
     private void resolveAckStrategy() {
-        //Only default for now
-        ackStrategy = type.getDefaultAckType();
+        ackStrategy =
+                Optional.ofNullable(method.getAnnotation(Acknowledgment.class))
+                        .map(Acknowledgment::value)
+                        .orElse(type.getDefaultAckType());
     }
 }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 4863dd66e41..453d697c00f 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -49,6 +49,7 @@ class IncomingMethod extends AbstractMethod {
     }
 
     void validate() {
+        super.validate();
         if (getIncomingChannelName() == null || getIncomingChannelName().trim().isEmpty()) {
             throw new DeploymentException(String
                     .format("Missing channel name in annotation @Incoming on method %s", getMethod().toString()));
@@ -83,7 +84,7 @@ public void init(BeanManager beanManager, Config config) {
             }
         } else {
             // Invoke on each message subscriber
-            subscriber = new InternalSubscriber(getMethod(), getBeanInstance());
+            subscriber = new InternalSubscriber(this);
         }
     }
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
index fa4df126d7c..ac61239189e 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
@@ -21,6 +21,7 @@
 import java.lang.reflect.Method;
 import java.util.concurrent.ExecutionException;
 
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
@@ -69,11 +70,11 @@ public void onNext(Object incomingValue) {
             //Params size is already validated by ProcessorMethod
             Class paramType = method.getParameterTypes()[0];
             Object processedValue = method.invoke(processorMethod.getBeanInstance(),
-                    MessageUtils.unwrap(incomingValue, paramType));
+                    preProcess(incomingValue, paramType));
             //Method returns publisher, time for flattening its PROCESSOR_MSG_2_PUBLISHER or *_BUILDER
             if (processedValue instanceof Publisher || processedValue instanceof PublisherBuilder) {
                 //Flatten, we are sure its invoke on every request method now
-                PublisherBuilder publisherBuilder = null;
+                PublisherBuilder publisherBuilder;
                 if (processedValue instanceof Publisher) {
                     publisherBuilder = ReactiveStreams.fromPublisher((Publisher) processedValue);
                 } else {
@@ -81,21 +82,38 @@ public void onNext(Object incomingValue) {
                 }
                 publisherBuilder.forEach(subVal -> {
                     try {
-                        subscriber.onNext(wrapValue(subVal));
+                        subscriber.onNext(postProcess(incomingValue, subVal));
                     } catch (ExecutionException | InterruptedException e) {
                         subscriber.onError(e);
                     }
                 }).run();
             } else {
-                subscriber.onNext(wrapValue(processedValue));
+                subscriber.onNext(postProcess(incomingValue, processedValue));
             }
         } catch (IllegalAccessException | InvocationTargetException | ExecutionException | InterruptedException e) {
             subscriber.onError(e);
         }
     }
 
-    private Object wrapValue(Object value) throws ExecutionException, InterruptedException {
-        return MessageUtils.unwrap(value, Message.class);
+    @SuppressWarnings("unchecked")
+    private Object preProcess(Object incomingValue, Class expectedParamType) throws ExecutionException, InterruptedException {
+        if (processorMethod.getAckStrategy().equals(Acknowledgment.Strategy.PRE_PROCESSING)
+                && incomingValue instanceof Message) {
+            Message incomingMessage = (Message) incomingValue;
+            incomingMessage.ack().toCompletableFuture().complete(incomingMessage.getPayload());
+        }
+
+        return MessageUtils.unwrap(incomingValue, expectedParamType);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Object postProcess(Object incomingValue, Object outgoingValue) throws ExecutionException, InterruptedException {
+        Message wrappedOutgoing = (Message) MessageUtils.unwrap(outgoingValue, Message.class);
+        if (processorMethod.getAckStrategy().equals(Acknowledgment.Strategy.POST_PROCESSING)) {
+            Message wrappedIncoming = (Message) MessageUtils.unwrap(incomingValue, Message.class);
+            wrappedOutgoing = (Message) MessageUtils.unwrap(outgoingValue, Message.class, wrappedIncoming::ack);
+        }
+        return wrappedOutgoing;
     }
 
     @Override
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
index 5715561147f..801eff02840 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
@@ -18,12 +18,14 @@
 package io.helidon.microprofile.messaging.channel;
 
 import java.lang.reflect.Method;
-import java.util.UUID;
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
 
-import io.helidon.common.context.Context;
-import io.helidon.common.context.Contexts;
 import io.helidon.microprofile.messaging.MessagingStreamException;
 
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Message;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
@@ -33,12 +35,10 @@
 class InternalSubscriber implements Subscriber {
 
     private Subscription subscription;
-    private Method method;
-    private Object beanInstance;
+    private IncomingMethod incomingMethod;
 
-    InternalSubscriber(Method method, Object beanInstance) {
-        this.method = method;
-        this.beanInstance = beanInstance;
+    InternalSubscriber(IncomingMethod incomingMethod) {
+        this.incomingMethod = incomingMethod;
     }
 
     @Override
@@ -49,17 +49,14 @@ public void onSubscribe(Subscription s) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void onNext(Object message) {
+        Method method = incomingMethod.getMethod();
         try {
-            Class paramType = this.method.getParameterTypes()[0];
-
-            Context parentContext = Context.create();
-            Context context = Context
-                    .builder()
-                    .parent(parentContext)
-                    .id(String.format("%s:message-%s", parentContext.id(), UUID.randomUUID().toString()))
-                    .build();
-            Contexts.runInContext(context, () -> this.method.invoke(this.beanInstance, MessageUtils.unwrap(message, paramType)));
+            Class paramType = method.getParameterTypes()[0];
+            Object preProcessedMessage = preProcess(message, paramType);
+            Object methodResult = method.invoke(incomingMethod.getBeanInstance(), preProcessedMessage);
+            postProcess(message, methodResult);
             subscription.request(1);
         } catch (Exception e) {
             // Notify publisher to stop sending
@@ -68,6 +65,36 @@ public void onNext(Object message) {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private Object preProcess(Object incomingValue, Class expectedParamType) throws ExecutionException, InterruptedException {
+        if (incomingMethod.getAckStrategy().equals(Acknowledgment.Strategy.PRE_PROCESSING)
+                && incomingValue instanceof Message) {
+            Message incomingMessage = (Message) incomingValue;
+            incomingMessage.ack().toCompletableFuture().complete(incomingMessage.getPayload());
+        }
+
+        return MessageUtils.unwrap(incomingValue, expectedParamType);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void postProcess(Object incomingValue, Object outgoingValue) throws ExecutionException, InterruptedException {
+        if (incomingMethod.getAckStrategy().equals(Acknowledgment.Strategy.POST_PROCESSING)
+                && incomingValue instanceof Message
+                && Objects.nonNull(outgoingValue)
+                && outgoingValue instanceof CompletionStage) {
+            Message incomingMessage = (Message) incomingValue;
+            CompletionStage completionStage = (CompletionStage) outgoingValue;
+            Object result = completionStage.toCompletableFuture().get();
+            incomingMessage.ack().toCompletableFuture()
+                    .complete(result);
+
+        } else if (Objects.nonNull(outgoingValue)
+                && outgoingValue instanceof CompletionStage) {
+            CompletionStage completionStage = (CompletionStage) outgoingValue;
+            completionStage.toCompletableFuture().get();
+        }
+    }
+
     @Override
     public void onError(Throwable t) {
         throw new MessagingStreamException(t);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
index e28f9447d9c..49e2bb36dd1 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
@@ -22,7 +22,9 @@
 import java.lang.reflect.Type;
 import java.security.InvalidParameterException;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
+import java.util.function.Supplier;
 
 import javax.enterprise.inject.spi.DeploymentException;
 
@@ -41,7 +43,7 @@ private MessageUtils() {
 
     /**
      * Unwrap values to expected types.
-     * 
    
+     * 
    
      * Examples:
      * 
    {@code
      * Message>>
@@ -57,11 +59,34 @@ private MessageUtils() {
      * @throws InterruptedException can happen when unwrapping completable
      */
     static Object unwrap(Object value, Class type) throws ExecutionException, InterruptedException {
+        return unwrap(value, type, () -> CompletableFuture.completedFuture((Void) null));
+    }
+
+    /**
+     * Unwrap values to expected types.
+     * 
    
+     * Examples:
+     * 
    {@code
+     * Message>>
+     * Message>
+     * CompletableFuture>
+     * Message
+     * }
    
+     *
+     * @param value value for unwrap
+     * @param type  expected type
+     * @param onAck {@link java.util.function.Supplier} in case of message wrapping is used for completion stage inferring
+     * @return unwrapped value
+     * @throws ExecutionException   can happen when unwrapping completable
+     * @throws InterruptedException can happen when unwrapping completable
+     */
+    static Object unwrap(Object value, Class type, Supplier> onAck)
+            throws ExecutionException, InterruptedException {
         if (type.equals(Message.class)) {
             if (value instanceof Message) {
                 return value;
             } else {
-                return Message.of(value);
+                return Message.of(value, onAck);
             }
         } else {
             if (value instanceof Message) {
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
index 59ade5d9211..adc64ba82d5 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MethodSignatureType.java
@@ -224,13 +224,14 @@ public enum MethodSignatureType {
      * Invoke at: every incoming
      * 
    O method(I payload)
    
      * 
      
-     *  
    • Default acknowledgment strategy: PRE_PROCESSING
      • 
-     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING
      • 
+     *  
    • Default acknowledgment strategy: POST_PROCESSING
      • 
+     *  
    • Supported acknowledgment strategies: NONE, PRE_PROCESSING, POST_PROCESSING
      • 
      * 
    
      */
-    PROCESSOR_PAYL_2_PAYL(false, Acknowledgment.Strategy.PRE_PROCESSING,
+    PROCESSOR_PAYL_2_PAYL(false, Acknowledgment.Strategy.POST_PROCESSING,
             Acknowledgment.Strategy.NONE,
-            Acknowledgment.Strategy.PRE_PROCESSING
+            Acknowledgment.Strategy.PRE_PROCESSING,
+            Acknowledgment.Strategy.POST_PROCESSING
     ),
     /**
      * Processor method signature type.
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
index 183cce9da18..ceb3910d194 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/OutgoingMethod.java
@@ -66,6 +66,7 @@ public void init(BeanManager beanManager, Config config) {
     }
 
     void validate() {
+        super.validate();
         if (getOutgoingChannelName() == null || getOutgoingChannelName().trim().isEmpty()) {
             throw new DeploymentException(String
                     .format("Missing channel name in annotation @Outgoing, method: %s", getMethod()));
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
index 5ef0c2d2949..be630358ee3 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProcessorMethod.java
@@ -51,6 +51,7 @@ public void init(BeanManager beanManager, Config config) {
 
     @Override
     public void validate() {
+        super.validate();
         if (getIncomingChannelName() == null || getIncomingChannelName().trim().isEmpty()) {
             throw new DeploymentException(String
                     .format("Missing channel name in annotation @Incoming on method %s", getMethod()));
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
index 54fc7fdc172..1d20bc004bc 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/IncomingConnector.java
@@ -28,7 +28,7 @@
 
 /**
  * Connector as defined in configuration.
- * 
    
+ * 
    
  * 
    {@code
  * mp.messaging.incoming.[channel-name].connector=[connector-name]
  * ...
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
index eb3fe2c265c..bb930080862 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/OutgoingConnector.java
@@ -29,7 +29,7 @@
 
 /**
  * Connector as defined in configuration.
- * 
    
+ * 
    
  * 
    {@code
  * mp.messaging.incoming.[channel-name].connector=[connector-name]
  * ...
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index 730499c45c4..cac6d9116eb 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -16,20 +16,6 @@
 
 package io.helidon.microprofile.messaging;
 
-import io.helidon.config.Config;
-import io.helidon.config.ConfigSources;
-import io.helidon.messaging.kafka.connector.KafkaConnectorFactory;
-import io.helidon.microprofile.config.MpConfig;
-import io.helidon.microprofile.config.MpConfigProviderResolver;
-import io.helidon.microprofile.messaging.kafka.KafkaCdiExtensionTest;
-import io.helidon.microprofile.server.Server;
-import org.eclipse.microprofile.reactive.messaging.spi.Connector;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-
-import javax.enterprise.inject.se.SeContainer;
-import javax.enterprise.inject.se.SeContainerInitializer;
-
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.annotation.Annotation;
@@ -46,36 +32,32 @@
 import java.util.logging.LogManager;
 import java.util.stream.Collectors;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.notNullValue;
+import javax.enterprise.inject.se.SeContainer;
+import javax.enterprise.inject.se.SeContainerInitializer;
+
+import io.helidon.config.Config;
+import io.helidon.config.ConfigSources;
+import io.helidon.microprofile.config.MpConfig;
+import io.helidon.microprofile.config.MpConfigProviderResolver;
+import io.helidon.microprofile.server.Server;
+
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
 public abstract class AbstractCDITest {
 
     static {
-        try (InputStream is = KafkaCdiExtensionTest.class.getResourceAsStream("/logging.properties")) {
+        try (InputStream is = AbstractCDITest.class.getResourceAsStream("/logging.properties")) {
             LogManager.getLogManager().readConfiguration(is);
         } catch (IOException e) {
             fail(e);
         }
     }
 
-    protected static final Connector KAFKA_CONNECTOR_LITERAL = new Connector() {
-
-        @Override
-        public Class annotationType() {
-            return Connector.class;
-        }
-
-        @Override
-        public String value() {
-            return KafkaConnectorFactory.CONNECTOR_NAME;
-        }
-    };
-
     protected SeContainer cdiContainer;
 
     protected Map cdiConfig() {
@@ -133,7 +115,7 @@ private static SeContainer startCdiContainer(Map p, Set
                                 .config(config).build(),
                         Thread.currentThread().getContextClassLoader());
         final SeContainerInitializer initializer = SeContainerInitializer.newInstance();
-        assertThat(initializer, is(notNullValue()));
+        assertNotNull(initializer);
         initializer.addBeanClasses(beanClasses.toArray(new Class[0]));
         return initializer.initialize();
     }
@@ -180,10 +162,10 @@ public List> getCountableBeanClasses() {
         }
 
         @SuppressWarnings("unchecked")
-        public List> getCompletableBeanClasses() {
+        public List> getCompletableBeanClasses() {
             return Arrays.stream(clazzes)
-                    .filter(CompletableTestBean.class::isAssignableFrom)
-                    .map(c -> (Class) c)
+                    .filter(AssertableTestBean.class::isAssignableFrom)
+                    .map(c -> (Class) c)
                     .collect(Collectors.toList());
         }
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertableTestBean.java
similarity index 74%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertableTestBean.java
index 2b36ccd74a9..6c7a1b83ae5 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/CompletableTestBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AssertableTestBean.java
@@ -17,8 +17,12 @@
 
 package io.helidon.microprofile.messaging;
 
-import java.util.concurrent.CompletionStage;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
 
-public interface CompletableTestBean {
-    CompletionStage getTestCompletion();
+public interface AssertableTestBean {
+    public static Set TEST_DATA = new HashSet<>(Arrays.asList("teST1", "TEst2", "tESt3"));
+
+    void assertValid();
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
index 460ffaf4029..9ed5b8fd02b 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MethodSignatureResolverTest.java
@@ -30,10 +30,11 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
-import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -47,8 +48,6 @@
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
-
 class MethodSignatureResolverTest {
 
     @Incoming("in-channel-name")
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
index b19dc2092f1..07cba2ab298 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
@@ -17,18 +17,16 @@
 
 package io.helidon.microprofile.messaging.connector;
 
+import java.util.Map;
+
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
-import io.helidon.microprofile.messaging.connector.AdHocConfigBuilder;
-
-import org.apache.kafka.common.serialization.LongSerializer;
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
 
 import static io.helidon.common.CollectionsHelper.mapOf;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import org.junit.jupiter.api.Test;
+
 class AdHocConfigBuilderTest {
 
     private static final String TEST_TOPIC_CONFIG = "TEST_TOPIC_CONFIG";
@@ -43,7 +41,7 @@ class AdHocConfigBuilderTest {
     @Test
     void currentContext() {
         Map propMap = mapOf(
-                "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName()
+                "mp.messaging.outcoming.test-channel.key.serializer", AdHocConfigBuilderTest.class.getName()
         );
 
         Config config = Config.builder()
@@ -56,14 +54,14 @@ void currentContext() {
                 .build();
 
         assertEquals(TEST_TOPIC_CUSTOM, c.getValue(TEST_KEY, String.class));
-        assertEquals(LongSerializer.class.getName(), c.getValue("key.serializer", String.class));
+        assertEquals(AdHocConfigBuilderTest.class.getName(), c.getValue("key.serializer", String.class));
     }
 
     @Test
     void customValueOverride() {
         Map propMap = mapOf(
                 "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG,
-                "mp.messaging.outcoming.test-channel.key.serializer", LongSerializer.class.getName()
+                "mp.messaging.outcoming.test-channel.key.serializer", AdHocConfigBuilderTest.class.getName()
         );
 
         Config config = Config.builder()
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
index ea6ec3ab4b5..8328235b646 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/InnerChannelTest.java
@@ -18,27 +18,23 @@
 package io.helidon.microprofile.messaging.inner;
 
 import java.util.Collections;
+import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
+import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.inject.spi.CDI;
 
 import io.helidon.microprofile.messaging.AbstractCDITest;
-import io.helidon.microprofile.messaging.CompletableTestBean;
+import io.helidon.microprofile.messaging.AssertableTestBean;
 import io.helidon.microprofile.messaging.CountableTestBean;
-import io.helidon.microprofile.messaging.inner.ack.ManualAckBean;
-import io.helidon.microprofile.messaging.inner.ack.ChainWithPayloadAckBean;
-
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.fail;
-
 
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.platform.commons.util.ClassFilter;
+import org.junit.platform.commons.util.ReflectionUtils;
 
 public class InnerChannelTest extends AbstractCDITest {
 
@@ -48,48 +44,11 @@ public void setUp() {
     }
 
     static Stream testCaseSource() {
-        return Stream.of(
-                //Positive tests
-                PublisherBuilderTransformerV2Bean.class,
-                PublisherBuilderTransformerV1Bean.class,
-                PublisherFromPublisherV2Bean.class,
-                PublisherFromPublisherV1Bean.class,
-                ProcessorBean.class,
-                ProcessorBuilderBean.class,
-                PullForEachBean.class,
-                CompletionStageV1Bean.class,
-                PublisherPayloadV6Bean.class,
-                PublisherPayloadV5Bean.class,
-                PublisherPayloadV4Bean.class,
-                PublisherPayloadV3Bean.class,
-                PublisherPayloadV1Bean.class,
-                PublisherSubscriberBuilderV2Bean.class,
-                PublisherSubscriberBuilderV1Bean.class,
-                PublisherSubscriberV2Bean.class,
-                PublisherSubscriberV1Bean.class,
-                InternalChannelsBean.class,
-                InnerProcessorBean.class,
-                MultipleProcessorBean.class,
-                MultipleTypeProcessorChainV1Bean.class,
-                MultipleTypeProcessorChainV2Bean.class,
-                ByRequestProcessorV5Bean.class,
-                ByRequestProcessorV4Bean.class,
-                ByRequestProcessorV3Bean.class,
-                ByRequestProcessorV2Bean.class,
-                ByRequestProcessorV1Bean.class,
-                PublisherProcessorV4Bean.class,
-                PublisherProcessorV3Bean.class,
-                PublisherProcessorV2Bean.class,
-                PublisherProcessorV1Bean.class,
-                //Ack tests
-//                ChainWithPayloadAckBean.class,
-//                ManualAckBean.class,
-
-                //Negative tests
-                NotConnectedIncommingChannelBean.class,
-                NotConnectedOutgoingChannelBean.class,
-                BadSignaturePublisherPayloadBean.class
-        ).map(CdiTestCase::from);
+        return ReflectionUtils
+                .findAllClassesInPackage(
+                        InnerChannelTest.class.getPackage().getName(),
+                        ClassFilter.of(c -> Objects.nonNull(c.getAnnotation(ApplicationScoped.class))))
+                .stream().map(CdiTestCase::from);
     }
 
     @ParameterizedTest
@@ -107,12 +66,8 @@ void innerChannelBeanTest(CdiTestCase testCase) {
                 assertAllReceived(countableTestBean);
             });
             testCase.getCompletableBeanClasses().forEach(c -> {
-                CompletableTestBean completableTestBean = CDI.current().select(c).get();
-                try {
-                    completableTestBean.getTestCompletion().toCompletableFuture().get(1, TimeUnit.SECONDS);
-                } catch (InterruptedException | TimeoutException | ExecutionException e) {
-                    fail(e);
-                }
+                AssertableTestBean assertableTestBean = CDI.current().select(c).get();
+                assertableTestBean.assertValid();
             });
         }
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java
new file mode 100644
index 00000000000..945ae583087
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingManualAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public CompletionStage receiveMessage(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+
+        CompletionStage ack = msg.ack();
+        ack.toCompletableFuture().complete(null);
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java
new file mode 100644
index 00000000000..3c446b4f8e4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPostProcessExplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java
new file mode 100644
index 00000000000..aaf330882a0
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPostProcessImplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java
new file mode 100644
index 00000000000..16dce57fe41
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPreProcessAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public CompletionStage receiveMessage(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/InvalidAckStrategy.java
similarity index 60%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/InvalidAckStrategy.java
index 223eedd0a1a..f5bb652ecb7 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ManualAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/InvalidAckStrategy.java
@@ -17,38 +17,23 @@
 
 package io.helidon.microprofile.messaging.inner.ack;
 
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-
 import javax.enterprise.context.ApplicationScoped;
 
-import io.helidon.microprofile.messaging.CompletableTestBean;
-import io.helidon.microprofile.reactive.MultiRS;
+import io.helidon.microprofile.messaging.AssertThrowException;
 
 import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ManualAckBean implements CompletableTestBean {
-
-    private CompletableFuture future = new CompletableFuture<>();
-
-    @Outgoing("test-channel")
-    public Publisher> produceMessage() {
-        return MultiRS.just(Message.of("test-data", () -> future));
-    }
+@AssertThrowException(Exception.class)
+public class InvalidAckStrategy {
 
-    @Incoming("test-channel")
+    @Outgoing("inner-processor")
     @Acknowledgment(Acknowledgment.Strategy.MANUAL)
-    public void receiveMessage(Message msg) {
-        msg.ack().toCompletableFuture().complete(null);
-    }
-
-    @Override
-    public CompletionStage getTestCompletion() {
-        return future;
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test")).buildRs();
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java
new file mode 100644
index 00000000000..4380eb7e3fa
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorManualAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public Message process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return Message.of(msg.getPayload(), msg::ack);
+    }
+
+    @Incoming("inner-consumer")
+    public CompletionStage receiveMessage(Message msg) {
+        msg.ack().toCompletableFuture().complete(null);
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java
new file mode 100644
index 00000000000..e4f3bc8233f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPostProcessExplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
+    public String process(String msg) {
+        return msg.toUpperCase();
+    }
+
+    @Incoming("inner-consumer")
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java
similarity index 60%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java
index 026ecbcec56..b37b52112c0 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ChainWithPayloadAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java
@@ -19,26 +19,30 @@
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import javax.enterprise.context.ApplicationScoped;
 
-import io.helidon.microprofile.messaging.CompletableTestBean;
-import io.helidon.microprofile.reactive.MultiRS;
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.fail;
 
-import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ChainWithPayloadAckBean implements CompletableTestBean {
+public class ProcessorPostProcessImplicitAckBean implements AssertableTestBean {
 
-    private CompletableFuture future = new CompletableFuture<>();
+    private CompletableFuture ackFuture = new CompletableFuture<>();
 
     @Outgoing("inner-processor")
     public Publisher> produceMessage() {
-        return MultiRS.just(Message.of("test-data", () -> future));
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
     }
 
     @Incoming("inner-processor")
@@ -48,13 +52,16 @@ public String process(String msg) {
     }
 
     @Incoming("inner-consumer")
-    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
-    public void receiveMessage(Message msg) {
-        msg.ack().toCompletableFuture().complete(null);
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
     }
 
     @Override
-    public CompletionStage getTestCompletion() {
-        return future;
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java
new file mode 100644
index 00000000000..7ee6a29c20a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPreProcessAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public String process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return msg.toUpperCase();
+    }
+
+    @Incoming("inner-consumer")
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV1Bean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV1Bean.java
index 3ba4d2f7de7..e9ab122720b 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -25,6 +25,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherBuilderTransformerV1Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV2Bean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV2Bean.java
index 16c3354b099..42463d5cef4 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherBuilderTransformerV2Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherBuilderTransformerV2Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -24,6 +24,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherBuilderTransformerV2Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV1Bean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV1Bean.java
index 1ab07e9e590..98efa504447 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherFromPublisherV1Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV2Bean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV2Bean.java
index 5184aeed4d8..1203493a7d1 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherFromPublisherV2Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherFromPublisherV2Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -25,6 +25,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherFromPublisherV2Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV1Bean.java
similarity index 91%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV1Bean.java
index 1e562cc2edf..1657f443a99 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherPayloadV1Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV3Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV3Bean.java
index 4c2d2b79e06..be0fc3f3d9f 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV3Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV3Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -29,6 +29,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executors;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherPayloadV3Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV4Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV4Bean.java
index 9b4eff0288f..6ab549beb36 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV4Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV4Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -29,6 +29,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executors;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherPayloadV4Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV5Bean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV5Bean.java
index 743371cccac..58b790ae2fc 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV5Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV5Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -29,6 +29,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executors;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherPayloadV5Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV6Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV6Bean.java
index bc26e9d9d76..ecc300afe26 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherPayloadV6Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherPayloadV6Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -29,6 +29,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executors;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherPayloadV6Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV1Bean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV1Bean.java
index 3d30eb3a363..4ae75f31c29 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import io.helidon.microprofile.messaging.CountableTestBean;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV2Bean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV2Bean.java
index 833efcbe58f..2a06de80f0e 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV2Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV2Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import io.helidon.microprofile.messaging.CountableTestBean;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV3Bean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV3Bean.java
index 939e0ab1675..5779be3dbd0 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV3Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV3Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import io.helidon.microprofile.messaging.CountableTestBean;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV4Bean.java
similarity index 97%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV4Bean.java
index 349ed251a48..c53af95dc05 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherProcessorV4Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherProcessorV4Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import io.helidon.microprofile.messaging.CountableTestBean;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV1Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV1Bean.java
index 4e590372127..b9f1650ea63 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherSubscriberBuilderV1Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV2Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV2Bean.java
index 7504bb76e3b..a510cef9b2d 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberBuilderV2Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberBuilderV2Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherSubscriberBuilderV2Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV1Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV1Bean.java
index 7fa6409ef23..f9e0dacd649 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV1Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV1Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherSubscriberV1Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV2Bean.java
similarity index 92%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV2Bean.java
index 0948f821993..00a3364be4b 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/PublisherSubscriberV2Bean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/publisher/PublisherSubscriberV2Bean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner;
+package io.helidon.microprofile.messaging.inner.publisher;
 
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
@@ -26,6 +26,8 @@
 
 import javax.enterprise.context.ApplicationScoped;
 
+import io.helidon.microprofile.messaging.inner.AbstractShapeTestBean;
+
 @ApplicationScoped
 public class PublisherSubscriberV2Bean extends AbstractShapeTestBean {
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplBean.java
new file mode 100644
index 00000000000..8fb0df58936
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.Executors;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToMsgRetComplBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("cs-void-message")
+    public Publisher> sourceForCsVoidMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("cs-void-message")
+    public CompletionStage consumeMessageAndReturnCompletionStageOfVoid(Message message) {
+        return CompletableFuture.runAsync(() -> RESULT_DATA.add(message.getPayload()), Executors.newSingleThreadExecutor());
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplStringBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplStringBean.java
new file mode 100644
index 00000000000..3fcc412902a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToMsgRetComplStringBean.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.Executors;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToMsgRetComplStringBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("cs-string-message")
+    public Publisher> sourceForCsStringMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("cs-string-message")
+    public CompletionStage consumeMessageAndReturnCompletionStageOfString(Message message) {
+        return CompletableFuture.supplyAsync(() -> {
+            RESULT_DATA.add(message.getPayload());
+            return "test";
+        }, Executors.newSingleThreadExecutor());
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylBean.java
new file mode 100644
index 00000000000..4759b6aa01d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylBean.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToPaylBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("void-payload")
+    public Publisher> sourceForVoidPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("void-payload")
+    public void consumePayload(String payload) {
+        RESULT_DATA.add(payload);
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplStringBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplStringBean.java
new file mode 100644
index 00000000000..f371b142a69
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplStringBean.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.Executors;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToPaylRetComplStringBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("cs-string-payload")
+    public Publisher> sourceForCsStringPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA).map(Message::of).buildRs();
+    }
+
+
+    @Incoming("cs-string-payload")
+    public CompletionStage consumePayloadAndReturnCompletionStageOfString(String payload) {
+        return CompletableFuture.supplyAsync(() -> {
+            RESULT_DATA.add(payload);
+            return "test";
+        }, Executors.newWorkStealingPool());
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplVoidBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplVoidBean.java
new file mode 100644
index 00000000000..25ef00a0dc4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetComplVoidBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.Executors;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToPaylRetComplVoidBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("cs-void-payload")
+    public Publisher> sourceForCsVoidPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("cs-void-payload")
+    public CompletionStage consumePayloadAndReturnCompletionStageOfVoid(String payload) {
+        return CompletableFuture.runAsync(() -> RESULT_DATA.add(payload), Executors.newSingleThreadExecutor());
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetPaylBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetPaylBean.java
new file mode 100644
index 00000000000..e09e371b360
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToPaylRetPaylBean.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToPaylRetPaylBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("string-payload")
+    public Publisher> sourceForStringPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("string-payload")
+    public String consumePayloadsAndReturnSomething(String payload) {
+        RESULT_DATA.add(payload);
+        return payload;
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsBuilderPaylBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsBuilderPaylBean.java
new file mode 100644
index 00000000000..50137988719
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsBuilderPaylBean.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublMsgToSubsBuilderPaylBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("subscriber-builder-payload")
+    public Publisher> sourceForSubscriberBuilderPayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("subscriber-builder-payload")
+    public SubscriberBuilder subscriberBuilderOfPayloads() {
+        return ReactiveStreams.builder()
+                .forEach(p -> RESULT_DATA.add(p));
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsPaylBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsPaylBean.java
new file mode 100644
index 00000000000..c49ff01cad9
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublMsgToSubsPaylBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class SubscriberPublMsgToSubsPaylBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("subscriber-payload")
+    public Publisher> sourceForSubscribePayload() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("subscriber-payload")
+    public Subscriber subscriberOfPayloads() {
+        return ReactiveStreams.builder()
+                .forEach(p -> RESULT_DATA.add(p))
+                .build();
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBean.java
new file mode 100644
index 00000000000..b5e748daf3e
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class SubscriberPublToSubsBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("subscriber-message")
+    public Publisher> sourceForSubscriberMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("subscriber-message")
+    public Subscriber> subscriberOfMessages() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> RESULT_DATA.add(m.getPayload()))
+                .build();
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBuilderBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBuilderBean.java
new file mode 100644
index 00000000000..68350051a79
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/subscriber/SubscriberPublToSubsBuilderBean.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.subscriber;
+
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class SubscriberPublToSubsBuilderBean implements AssertableTestBean {
+
+    CopyOnWriteArraySet RESULT_DATA = new CopyOnWriteArraySet<>();
+
+    @Outgoing("subscriber-builder-message")
+    public Publisher> sourceForSubscriberBuilderMessage() {
+        return ReactiveStreams.fromIterable(TEST_DATA)
+                .map(Message::of)
+                .buildRs();
+    }
+
+    @Incoming("subscriber-builder-message")
+    public SubscriberBuilder, Void> subscriberBuilderOfMessages() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> RESULT_DATA.add(m.getPayload()));
+    }
+
+    @Override
+    public void assertValid() {
+        assertTrue(RESULT_DATA.containsAll(TEST_DATA));
+        assertEquals(TEST_DATA.size(), RESULT_DATA.size());
+    }
+}
diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml
index 3b34cd73705..d25bbd30026 100644
--- a/microprofile/tests/tck/tck-messaging/pom.xml
+++ b/microprofile/tests/tck/tck-messaging/pom.xml
@@ -63,6 +63,35 @@
             arquillian-junit-container
             test
         
+        
+            javax.enterprise
+            cdi-api
+            provided
+        
+        
+            org.jboss.weld.se
+            weld-se-core
+        
+        
+            org.slf4j
+            slf4j-api
+        
+        
+            
+            org.slf4j
+            slf4j-jdk14
+        
+        
+            
+            javax.activation
+            javax.activation-api
+            provided
+        
         
             io.helidon.microprofile
             helidon-microprofile-messaging
@@ -85,6 +114,93 @@
                 
             
         
+
+        
+            javax.enterprise
+            cdi-api
+            provided
+        
+        
+            
+            javax.activation
+            javax.activation-api
+            provided
+        
+
+        
+            org.eclipse.microprofile.reactive.messaging
+            microprofile-reactive-messaging-api
+            1.0
+        
+
+        
+            io.helidon.microprofile.config
+            helidon-microprofile-config
+        
+        
+            io.helidon.microprofile.config
+            helidon-microprofile-config-cdi
+        
+        
+            io.helidon.microprofile.server
+            helidon-microprofile-server
+        
+        
+            io.helidon.microprofile
+            helidon-microprofile-messaging
+            1.3.2-SNAPSHOT
+        
+        
+            org.jboss.weld.se
+            weld-se-core
+        
+        
+            org.slf4j
+            slf4j-api
+        
+        
+            
+            org.slf4j
+            slf4j-jdk14
+        
+        
+            io.helidon.microprofile.bundles
+            internal-test-libs
+            test
+        
+        
+            org.jboss.weld
+            weld-junit5
+            test
+        
+        
+            
+            org.slf4j
+            slf4j-jdk14
+            1.7.28
+            test
+        
+        
+            com.salesforce.kafka.test
+            kafka-junit5
+            3.1.1
+            test
+        
+        
+            org.apache.kafka
+            kafka-clients
+            2.3.0
+        
+        
+            org.apache.kafka
+            kafka_2.11
+            2.3.0
+        
     
 
     

From 6119dc47c6adbaed91c3bc4ba32bc7814f0fa88e Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 26 Nov 2019 10:58:09 +0100
Subject: [PATCH 26/66] Ack impl for incoming methods aka subscribers

Signed-off-by: Daniel Kec 
---
 .../messaging/kafka/SimpleKafkaConsumer.java  |  28 ++--
 .../messaging/channel/IncomingMethod.java     |  13 +-
 .../messaging/channel/InternalSubscriber.java |  19 ++-
 .../messaging/channel/ProxySubscriber.java    |  80 ++++++++++
 .../IncomingMsgManualAckBean.java}            |   4 +-
 .../ack/incoming/IncomingMsgNoneAckBean.java  |  60 ++++++++
 ...ncomingMsgPostProcessExplicitAckBean.java} |   4 +-
 ...ncomingMsgPostProcessImplicitAckBean.java} |   4 +-
 .../IncomingMsgPreAckBean.java}               |   4 +-
 .../ack/incoming/IncomingPaylNoneAckBean.java |  58 +++++++
 .../IncomingPaylPostExplicitAckBean.java      |  66 ++++++++
 .../IncomingPaylPostImplicitAckBean.java      |  64 ++++++++
 .../ack/incoming/IncomingPaylPreAckBean.java  |  66 ++++++++
 ...mingSubscriberBuilderMsgManualAckBean.java |  79 ++++++++++
 ...comingSubscriberBuilderMsgNoneAckBean.java |  70 +++++++++
 ...bscriberBuilderMsgPostExplicitAckBean.java |  78 ++++++++++
 ...bscriberBuilderMsgPostImplicitAckBean.java |  76 ++++++++++
 ...ncomingSubscriberBuilderMsgPreAckBean.java |  77 ++++++++++
 ...scriberBuilderPaylPostImplicitAckBean.java |  76 ++++++++++
 .../IncomingSubscriberMsgManualAckBean.java   |  79 ++++++++++
 .../IncomingSubscriberMsgNoneAckBean.java     |  70 +++++++++
 ...omingSubscriberMsgPostExplicitAckBean.java |  79 ++++++++++
 ...omingSubscriberMsgPostImplicitAckBean.java |  77 ++++++++++
 .../IncomingSubscriberMsgPreAckBean.java      |  77 ++++++++++
 ...mingSubscriberPaylPostImplicitAckBean.java |  77 ++++++++++
 microprofile/tests/tck/tck-messaging/pom.xml  | 143 ++----------------
 26 files changed, 1364 insertions(+), 164 deletions(-)
 create mode 100644 microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxySubscriber.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{IncomingManualAckBean.java => incoming/IncomingMsgManualAckBean.java} (95%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgNoneAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{IncomingPostProcessExplicitAckBean.java => incoming/IncomingMsgPostProcessExplicitAckBean.java} (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{IncomingPostProcessImplicitAckBean.java => incoming/IncomingMsgPostProcessImplicitAckBean.java} (93%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{IncomingPreProcessAckBean.java => incoming/IncomingMsgPreAckBean.java} (95%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPreAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPreAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderPaylPostImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPreAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberPaylPostImplicitAckBean.java

diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
index d5b26acbed6..391eb6ae3f3 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
@@ -82,7 +82,7 @@ public class SimpleKafkaConsumer implements Closeable {
     private List topicNameList;
     private KafkaConsumer consumer;
 
-    private ConcurrentLinkedDeque> recordBuffer = new ConcurrentLinkedDeque<>();
+    private final ConcurrentLinkedDeque> backPressureBuffer = new ConcurrentLinkedDeque<>();
     private CopyOnWriteArrayList> ackFutures = new CopyOnWriteArrayList<>();
 
     /**
@@ -207,8 +207,8 @@ public void cancel() {
                 try {
                     while (!closed.get()) {
                         waitForAcksAndPoll();
-                        if (recordBuffer.isEmpty()) continue;
-                        ConsumerRecord cr = recordBuffer.poll();
+                        if (backPressureBuffer.isEmpty()) continue;
+                        ConsumerRecord cr = backPressureBuffer.poll();
                         KafkaMessage kafkaMessage = new KafkaMessage<>(cr);
                         ackFutures.add(kafkaMessage.getAckFuture());
                         runInNewContext(() -> subscriber.onNext(kafkaMessage));
@@ -225,16 +225,22 @@ public void cancel() {
         }));
     }
 
+    /**
+     * Naive impl of back pressure wise lazy poll.
+     * Wait for the last batch of records to be acknowledged before commit and another poll.
+     */
     private void waitForAcksAndPoll() {
-        if (recordBuffer.isEmpty()) {
-            try {
-                if (!ackFutures.isEmpty()) {
-                    CompletableFuture.allOf(ackFutures.toArray(new CompletableFuture[0])).get();
-                    consumer.commitSync();
+        synchronized (backPressureBuffer) {
+            if (backPressureBuffer.isEmpty()) {
+                try {
+                    if (!ackFutures.isEmpty()) {
+                        CompletableFuture.allOf(ackFutures.toArray(new CompletableFuture[0])).get();
+                        consumer.commitSync();
+                    }
+                    consumer.poll(Duration.ofSeconds(1)).forEach(backPressureBuffer::add);
+                } catch (InterruptedException | ExecutionException e) {
+                    LOGGER.log(Level.SEVERE, "Error when waiting for all polled records acknowledgements.", e);
                 }
-                consumer.poll(Duration.ofSeconds(1)).forEach(recordBuffer::add);
-            } catch (InterruptedException | ExecutionException e) {
-                LOGGER.log(Level.SEVERE, "Error when waiting for all polled records acknowledgements.", e);
             }
         }
     }
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
index 453d697c00f..f2f0aaf1c5d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/IncomingMethod.java
@@ -64,16 +64,19 @@ public void init(BeanManager beanManager, Config config) {
             try {
                 switch (getType()) {
                     case INCOMING_SUBSCRIBER_MSG_2_VOID:
-                        subscriber = (Subscriber) getMethod().invoke(getBeanInstance());
+                        Subscriber originalMsgSubscriber = (Subscriber) getMethod().invoke(getBeanInstance());
+                        subscriber = new ProxySubscriber(this, originalMsgSubscriber);
                         break;
                     case INCOMING_SUBSCRIBER_PAYL_2_VOID:
-                        subscriber = UnwrapProcessor.of(this.getMethod(), (Subscriber) getMethod()
-                                .invoke(getBeanInstance()));
+                        Subscriber originalPaylSubscriber = (Subscriber) getMethod().invoke(getBeanInstance());
+                        Subscriber unwrappedSubscriber = UnwrapProcessor.of(this.getMethod(), originalPaylSubscriber);
+                        subscriber = new ProxySubscriber(this, unwrappedSubscriber);
                         break;
                     case INCOMING_SUBSCRIBER_BUILDER_MSG_2_VOID:
                     case INCOMING_SUBSCRIBER_BUILDER_PAYL_2_VOID:
-                        subscriber = UnwrapProcessor.of(this.getMethod(),
-                                ((SubscriberBuilder) getMethod().invoke(getBeanInstance())).build());
+                        SubscriberBuilder originalSubscriberBuilder = (SubscriberBuilder) getMethod().invoke(getBeanInstance());
+                        Subscriber unwrappedBuilder = UnwrapProcessor.of(this.getMethod(), originalSubscriberBuilder.build());
+                        subscriber = new ProxySubscriber(this, unwrappedBuilder);
                         break;
                     default:
                         throw new UnsupportedOperationException(String
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
index 801eff02840..2e819f882be 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalSubscriber.java
@@ -79,15 +79,18 @@ private Object preProcess(Object incomingValue, Class expectedParamType) thro
     @SuppressWarnings("unchecked")
     private void postProcess(Object incomingValue, Object outgoingValue) throws ExecutionException, InterruptedException {
         if (incomingMethod.getAckStrategy().equals(Acknowledgment.Strategy.POST_PROCESSING)
-                && incomingValue instanceof Message
-                && Objects.nonNull(outgoingValue)
-                && outgoingValue instanceof CompletionStage) {
-            Message incomingMessage = (Message) incomingValue;
-            CompletionStage completionStage = (CompletionStage) outgoingValue;
-            Object result = completionStage.toCompletableFuture().get();
-            incomingMessage.ack().toCompletableFuture()
-                    .complete(result);
+                && incomingValue instanceof Message) {
 
+            Message incomingMessage = (Message) incomingValue;
+            if (Objects.nonNull(outgoingValue) && outgoingValue instanceof CompletionStage) {
+                CompletionStage completionStage = (CompletionStage) outgoingValue;
+                Object result = completionStage.toCompletableFuture().get();
+                incomingMessage.ack().toCompletableFuture().complete(result);
+
+            } else {
+                // returns void
+                incomingMessage.ack().toCompletableFuture().complete(null);
+            }
         } else if (Objects.nonNull(outgoingValue)
                 && outgoingValue instanceof CompletionStage) {
             CompletionStage completionStage = (CompletionStage) outgoingValue;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxySubscriber.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxySubscriber.java
new file mode 100644
index 00000000000..3756ac00fa0
--- /dev/null
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxySubscriber.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.channel;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/**
+ * Subscriber wrapper used to invoke pre-process and post-process logic.
+ *
+ * @param  type of the subscriber value
+ */
+class ProxySubscriber implements Subscriber {
+
+    private IncomingMethod method;
+    private Subscriber originalSubscriber;
+
+    ProxySubscriber(IncomingMethod method, Subscriber originalSubscriber) {
+        this.method = method;
+        this.originalSubscriber = originalSubscriber;
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        originalSubscriber.onSubscribe(s);
+    }
+
+    @Override
+    public void onNext(T o) {
+        originalSubscriber.onNext(preProcess(o));
+        postProcess(o);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        originalSubscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        originalSubscriber.onComplete();
+    }
+
+    @SuppressWarnings("unchecked")
+    private T preProcess(T incomingValue) {
+        if (method.getAckStrategy().equals(Acknowledgment.Strategy.PRE_PROCESSING)
+                && incomingValue instanceof Message) {
+            Message incomingMessage = (Message) incomingValue;
+            incomingMessage.ack().toCompletableFuture().complete(incomingMessage.getPayload());
+        }
+
+        return incomingValue;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void postProcess(T incomingValue) {
+        if (method.getAckStrategy().equals(Acknowledgment.Strategy.POST_PROCESSING)
+                && incomingValue instanceof Message) {
+            Message incomingMessage = (Message) incomingValue;
+            incomingMessage.ack().toCompletableFuture().complete(null);
+        }
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgManualAckBean.java
similarity index 95%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgManualAckBean.java
index 945ae583087..24b4cd36fac 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingManualAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgManualAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.incoming;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -39,7 +39,7 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class IncomingManualAckBean implements AssertableTestBean {
+public class IncomingMsgManualAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
     private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgNoneAckBean.java
new file mode 100644
index 00000000000..a7ba19b2f10
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgNoneAckBean.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingMsgNoneAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public CompletionStage receiveMessage(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessExplicitAckBean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessExplicitAckBean.java
index 3c446b4f8e4..ad2b9a16455 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessExplicitAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessExplicitAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.incoming;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -37,7 +37,7 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class IncomingPostProcessExplicitAckBean implements AssertableTestBean {
+public class IncomingMsgPostProcessExplicitAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessImplicitAckBean.java
similarity index 93%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessImplicitAckBean.java
index aaf330882a0..b085696c824 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPostProcessImplicitAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPostProcessImplicitAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.incoming;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -36,7 +36,7 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class IncomingPostProcessImplicitAckBean implements AssertableTestBean {
+public class IncomingMsgPostProcessImplicitAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPreAckBean.java
similarity index 95%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPreAckBean.java
index 16dce57fe41..f638b3865b3 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/IncomingPreProcessAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingMsgPreAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.incoming;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -39,7 +39,7 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class IncomingPreProcessAckBean implements AssertableTestBean {
+public class IncomingMsgPreAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
     private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylNoneAckBean.java
new file mode 100644
index 00000000000..44f7d3d8e5b
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylNoneAckBean.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPaylNoneAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostExplicitAckBean.java
new file mode 100644
index 00000000000..ec628dff156
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostExplicitAckBean.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPaylPostExplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedPre = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
+    public void receiveMessage(String msg) {
+        completedPre.set(ackFuture.isDone());
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedPre.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostImplicitAckBean.java
new file mode 100644
index 00000000000..d4e9eec09f0
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPostImplicitAckBean.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPaylPostImplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedPre = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public void receiveMessage(String msg) {
+        completedPre.set(ackFuture.isDone());
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedPre.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPreAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPreAckBean.java
new file mode 100644
index 00000000000..fd81f4c1a1e
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingPaylPreAckBean.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingPaylPreAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedPre = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        completedPre.set(ackFuture.isDone());
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedPre.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgManualAckBean.java
new file mode 100644
index 00000000000..10f17d3b8b4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgManualAckBean.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderMsgManualAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public SubscriberBuilder, Void> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                    m.ack();
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgNoneAckBean.java
new file mode 100644
index 00000000000..29e430841fc
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgNoneAckBean.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderMsgNoneAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public SubscriberBuilder, Void> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(completedBeforeProcessor.get());
+        assertFalse(ackFuture.isDone());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostExplicitAckBean.java
new file mode 100644
index 00000000000..2f7b20be5bc
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostExplicitAckBean.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderMsgPostExplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
+    public SubscriberBuilder, Void> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostImplicitAckBean.java
new file mode 100644
index 00000000000..67d5b1abcbd
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPostImplicitAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderMsgPostImplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public SubscriberBuilder, Void> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPreAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPreAckBean.java
new file mode 100644
index 00000000000..19b3a22bfa6
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderMsgPreAckBean.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderMsgPreAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public SubscriberBuilder, Void> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderPaylPostImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderPaylPostImplicitAckBean.java
new file mode 100644
index 00000000000..ccccaa00ecb
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberBuilderPaylPostImplicitAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class IncomingSubscriberBuilderPaylPostImplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public SubscriberBuilder receiveMessage() {
+        return ReactiveStreams.builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m));
+                });
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgManualAckBean.java
new file mode 100644
index 00000000000..69acc2cccbb
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgManualAckBean.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberMsgManualAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public Subscriber> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                    m.ack();
+                }).build();
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgNoneAckBean.java
new file mode 100644
index 00000000000..124af70210e
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgNoneAckBean.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberMsgNoneAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Subscriber> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                }).build();
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(completedBeforeProcessor.get());
+        assertFalse(ackFuture.isDone());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostExplicitAckBean.java
new file mode 100644
index 00000000000..54c900efcd4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostExplicitAckBean.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberMsgPostExplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
+    public Subscriber> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                })
+                .build();
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostImplicitAckBean.java
new file mode 100644
index 00000000000..8cf5c7f6aaa
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPostImplicitAckBean.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberMsgPostImplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public Subscriber> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                })
+                .build();
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPreAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPreAckBean.java
new file mode 100644
index 00000000000..dc5a140b499
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberMsgPreAckBean.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberMsgPreAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public Subscriber> receiveMessage() {
+        return ReactiveStreams.>builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m.getPayload()));
+                }).build();
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberPaylPostImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberPaylPostImplicitAckBean.java
new file mode 100644
index 00000000000..f389f265159
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/incoming/IncomingSubscriberPaylPostImplicitAckBean.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.incoming;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+@ApplicationScoped
+public class IncomingSubscriberPaylPostImplicitAckBean implements AssertableTestBean {
+
+    private static final String TEST_MSG = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicBoolean interceptedMessage = new AtomicBoolean(false);
+
+    @Outgoing("test-channel")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_MSG, () -> {
+            ackFuture.complete(null);
+            return CompletableFuture.completedFuture(null);
+        })).buildRs();
+    }
+
+    @Incoming("test-channel")
+    public Subscriber receiveMessage() {
+        return ReactiveStreams.builder()
+                .forEach(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    interceptedMessage.set(TEST_MSG.equals(m));
+                })
+                .build();
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertTrue(interceptedMessage.get());
+    }
+}
diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml
index d25bbd30026..6e908a86c71 100644
--- a/microprofile/tests/tck/tck-messaging/pom.xml
+++ b/microprofile/tests/tck/tck-messaging/pom.xml
@@ -30,22 +30,6 @@
     Helidon Microprofile Tests TCK Messaging
 
     
-        
-            org.eclipse.microprofile.reactive.messaging
-            microprofile-reactive-messaging-tck
-            1.0
-            
-                
-                    rxjava
-                    io.reactivex.rxjava2
-                
-            
-        
-        
-            io.reactivex.rxjava2
-            rxjava
-            2.2.13
-        
         
             io.helidon.microprofile.tests
             helidon-arquillian
@@ -58,40 +42,6 @@
                 
             
         
-        
-            org.jboss.arquillian.junit
-            arquillian-junit-container
-            test
-        
-        
-            javax.enterprise
-            cdi-api
-            provided
-        
-        
-            org.jboss.weld.se
-            weld-se-core
-        
-        
-            org.slf4j
-            slf4j-api
-        
-        
-            
-            org.slf4j
-            slf4j-jdk14
-        
-        
-            
-            javax.activation
-            javax.activation-api
-            provided
-        
         
             io.helidon.microprofile
             helidon-microprofile-messaging
@@ -114,92 +64,21 @@
                 
             
         
-
-        
-            javax.enterprise
-            cdi-api
-            provided
-        
-        
-            
-            javax.activation
-            javax.activation-api
-            provided
-        
-
         
             org.eclipse.microprofile.reactive.messaging
-            microprofile-reactive-messaging-api
+            microprofile-reactive-messaging-tck
             1.0
-        
-
-        
-            io.helidon.microprofile.config
-            helidon-microprofile-config
-        
-        
-            io.helidon.microprofile.config
-            helidon-microprofile-config-cdi
-        
-        
-            io.helidon.microprofile.server
-            helidon-microprofile-server
-        
-        
-            io.helidon.microprofile
-            helidon-microprofile-messaging
-            1.3.2-SNAPSHOT
-        
-        
-            org.jboss.weld.se
-            weld-se-core
-        
-        
-            org.slf4j
-            slf4j-api
-        
-        
-            
-            org.slf4j
-            slf4j-jdk14
-        
-        
-            io.helidon.microprofile.bundles
-            internal-test-libs
-            test
-        
-        
-            org.jboss.weld
-            weld-junit5
-            test
-        
-        
-            
-            org.slf4j
-            slf4j-jdk14
-            1.7.28
-            test
-        
-        
-            com.salesforce.kafka.test
-            kafka-junit5
-            3.1.1
-            test
-        
-        
-            org.apache.kafka
-            kafka-clients
-            2.3.0
+            
+                
+                    rxjava
+                    io.reactivex.rxjava2
+                
+            
         
         
-            org.apache.kafka
-            kafka_2.11
-            2.3.0
+            io.reactivex.rxjava2
+            rxjava
+            2.2.13
         
     
 
@@ -208,7 +87,7 @@
             
                 org.apache.maven.plugins
                 maven-surefire-plugin
-                false    
+                false
                 
                     
                         org.eclipse.microprofile.reactive.messaging:microprofile-reactive-messaging-tck

From 1114a7d82b8d5aadbc5e23731fad626522966e97 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 26 Nov 2019 15:16:38 +0100
Subject: [PATCH 27/66] Full Ack impl

Signed-off-by: Daniel Kec 
---
 .../messaging/channel/InternalProcessor.java  |  6 ++
 .../messaging/channel/MessageUtils.java       | 15 +---
 .../messaging/channel/ProxyProcessor.java     | 12 +++
 .../messaging/channel/MessageUtilsTest.java   | 34 ++++----
 .../ProcessorMsg2ComplStageManualAckBean.java | 85 ++++++++++++++++++
 .../ProcessorMsg2ComplStageNoneAckBean.java   | 78 +++++++++++++++++
 .../ProcessorMsg2ComplStagePrepAckBean.java   | 85 ++++++++++++++++++
 .../ProcessorMsg2MsgManualAckBean.java}       | 11 ++-
 .../ProcessorMsg2MsgNoneAckBean.java          | 70 +++++++++++++++
 .../ProcessorMsg2MsgPrepExplicitAckBean.java  | 78 +++++++++++++++++
 .../ProcessorMsg2MsgPrepImplicitAckBean.java  | 77 ++++++++++++++++
 ...rPayl2PaylPostProcessExplicitAckBean.java} |  9 +-
 ...rPayl2PaylPostProcessImplicitAckBean.java} | 11 ++-
 .../ProcessorPayl2PaylPreProcessAckBean.java} |  4 +-
 ...rProcessorBuilderMsg2MsgManualAckBean.java | 86 ++++++++++++++++++
 ...sorProcessorBuilderMsg2MsgNoneAckBean.java | 75 ++++++++++++++++
 ...ssorBuilderMsg2MsgPrepExplicitAckBean.java | 86 ++++++++++++++++++
 ...ssorBuilderMsg2MsgPrepImplicitAckBean.java | 85 ++++++++++++++++++
 ...rProcessorBuilderPayl2PaylNoneAckBean.java | 75 ++++++++++++++++
 ...orBuilderPayl2PaylPrepImplicitAckBean.java | 82 +++++++++++++++++
 ...rocessorProcessorMsg2MsgManualAckBean.java | 87 +++++++++++++++++++
 .../ProcessorProcessorMsg2MsgNoneAckBean.java | 76 ++++++++++++++++
 ...orProcessorMsg2MsgPrepExplicitAckBean.java | 87 +++++++++++++++++++
 ...orProcessorMsg2MsgPrepImplicitAckBean.java | 86 ++++++++++++++++++
 ...rocessorProcessorPayl2PaylNoneAckBean.java | 76 ++++++++++++++++
 ...ProcessorPayl2PaylPrepImplicitAckBean.java | 84 ++++++++++++++++++
 ...rPublisherBuilderMsg2MsgManualAckBean.java | 85 ++++++++++++++++++
 ...sorPublisherBuilderMsg2MsgNoneAckBean.java | 76 ++++++++++++++++
 ...sherBuilderMsg2MsgPrepExplicitAckBean.java | 84 ++++++++++++++++++
 ...sherBuilderMsg2MsgPrepImplicitAckBean.java | 83 ++++++++++++++++++
 ...rPublisherBuilderPayl2PaylNoneAckBean.java | 76 ++++++++++++++++
 ...erBuilderPayl2PaylPrepExplicitAckBean.java | 84 ++++++++++++++++++
 ...erBuilderPayl2PaylPrepImplicitAckBean.java | 83 ++++++++++++++++++
 ...rocessorPublisherMsg2MsgManualAckBean.java | 84 ++++++++++++++++++
 .../ProcessorPublisherMsg2MsgNoneAckBean.java | 75 ++++++++++++++++
 ...orPublisherMsg2MsgPrepExplicitAckBean.java | 83 ++++++++++++++++++
 ...orPublisherMsg2MsgPrepImplicitAckBean.java | 82 +++++++++++++++++
 ...rocessorPublisherPayl2PaylNoneAckBean.java | 75 ++++++++++++++++
 ...PublisherPayl2PaylPrepExplicitAckBean.java | 83 ++++++++++++++++++
 ...PublisherPayl2PaylPrepImplicitAckBean.java | 82 +++++++++++++++++
 40 files changed, 2656 insertions(+), 39 deletions(-)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStagePrepAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ProcessorManualAckBean.java => processor/ProcessorMsg2MsgManualAckBean.java} (89%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepImplicitAckBean.java
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ProcessorPostProcessExplicitAckBean.java => processor/ProcessorPayl2PaylPostProcessExplicitAckBean.java} (83%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ProcessorPostProcessImplicitAckBean.java => processor/ProcessorPayl2PaylPostProcessImplicitAckBean.java} (78%)
 rename microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/{ProcessorPreProcessAckBean.java => processor/ProcessorPayl2PaylPreProcessAckBean.java} (94%)
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgManualAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepImplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylNoneAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepExplicitAckBean.java
 create mode 100644 microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepImplicitAckBean.java

diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
index ac61239189e..d4069b26420 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/InternalProcessor.java
@@ -19,6 +19,7 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 
 import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
@@ -108,6 +109,11 @@ private Object preProcess(Object incomingValue, Class expectedParamType) thro
 
     @SuppressWarnings("unchecked")
     private Object postProcess(Object incomingValue, Object outgoingValue) throws ExecutionException, InterruptedException {
+        if (outgoingValue instanceof CompletionStage) {
+            //Wait for completable stages to finish, yes it means to block see the spec
+            outgoingValue = ((CompletionStage) outgoingValue).toCompletableFuture().get();
+        }
+
         Message wrappedOutgoing = (Message) MessageUtils.unwrap(outgoingValue, Message.class);
         if (processorMethod.getAckStrategy().equals(Acknowledgment.Strategy.POST_PROCESSING)) {
             Message wrappedIncoming = (Message) MessageUtils.unwrap(incomingValue, Message.class);
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
index 49e2bb36dd1..be7eda8c14d 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/MessageUtils.java
@@ -90,26 +90,13 @@ static Object unwrap(Object value, Class type, Supplier
             }
         } else {
             if (value instanceof Message) {
-                Object payload = ((Message) value).getPayload();
-                return unwrapCompletableFuture(payload, type);
-            } else if (value instanceof CompletableFuture) {
-                //Recursion for Message>>
-                return unwrap(((CompletableFuture) value).get(), type);
+                return ((Message) value).getPayload();
             } else {
                 return value;
             }
         }
     }
 
-    private static Object unwrapCompletableFuture(Object o, Class expectedType)
-            throws ExecutionException, InterruptedException {
-        if (CompletableFuture.class.isInstance(o) && !CompletableFuture.class.isAssignableFrom(expectedType)) {
-            //Recursion for Message>>
-            return unwrap(((CompletableFuture) o).get(), expectedType);
-        }
-        return o;
-    }
-
     /**
      * Same as {@link io.helidon.microprofile.messaging.channel.MessageUtils#unwrap(java.lang.Object, java.lang.Class)}.
      * But extracts expected type from method reflexively.
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
index 98409eed39a..fef672993e8 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ProxyProcessor.java
@@ -22,6 +22,8 @@
 
 import javax.enterprise.inject.spi.DeploymentException;
 
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
@@ -114,6 +116,7 @@ public void onSubscribe(Subscription s) {
     @SuppressWarnings("unchecked")
     public void onNext(Object o) {
         try {
+            preProcess(o);
             subscriber.onNext(MessageUtils.unwrap(o, this.processorMethod.getMethod()));
         } catch (ExecutionException | InterruptedException e) {
             onError(e);
@@ -129,4 +132,13 @@ public void onError(Throwable t) {
     public void onComplete() {
         subscriber.onComplete();
     }
+
+    @SuppressWarnings("unchecked")
+    private void preProcess(Object incomingValue) {
+        if (processorMethod.getAckStrategy().equals(Acknowledgment.Strategy.PRE_PROCESSING)
+                && incomingValue instanceof Message) {
+            Message incomingMessage = (Message) incomingValue;
+            incomingMessage.ack().toCompletableFuture().complete(incomingMessage.getPayload());
+        }
+    }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
index 03dc88298cb..b3a7e5d04b1 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/channel/MessageUtilsTest.java
@@ -17,35 +17,39 @@
 
 package io.helidon.microprofile.messaging.channel;
 
-import org.eclipse.microprofile.reactive.messaging.Message;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import java.util.concurrent.CompletableFuture;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Stream;
 
-import io.helidon.microprofile.messaging.channel.MessageUtils;
-
-
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
 class MessageUtilsTest {
 
     @SuppressWarnings("unchecked")
     static Stream testSource() {
-        CompletableFuture stringFuture = new CompletableFuture<>();
-        stringFuture.complete("test");
-        CompletableFuture> messageFuture = new CompletableFuture<>();
-        messageFuture.complete(Message.of("test"));
         return Stream.of(
 
+                Tuple.of(5L, Long.class),
+                Tuple.of(5L, Message.class),
+                Tuple.of(5, Integer.class),
+                Tuple.of(5, Message.class),
+                Tuple.of(Double.parseDouble("50"), Double.class),
+                Tuple.of(Double.parseDouble("50"), Message.class),
+                Tuple.of(BigInteger.TEN, BigInteger.class),
+                Tuple.of(BigInteger.TEN, Message.class),
                 Tuple.of("test", String.class),
                 Tuple.of("test", Message.class),
                 Tuple.of(Message.of("test"), String.class),
-                Tuple.of(Message.of(stringFuture), String.class),
-                Tuple.of(messageFuture, String.class),
-                Tuple.of(Message.of(messageFuture), String.class)
+                Tuple.of(Message.of("test"), Message.class),
+                Tuple.of(Message.of(5L), Long.class),
+                Tuple.of(Message.of(5), Integer.class),
+                Tuple.of(Message.of(BigInteger.TEN), BigInteger.class),
+                Tuple.of(Message.of(BigDecimal.TEN), BigDecimal.class)
 
         );
     }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageManualAckBean.java
new file mode 100644
index 00000000000..e986df2f55d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageManualAckBean.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2ComplStageManualAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public CompletionStage> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return CompletableFuture.supplyAsync(() -> Message.of(msg.getPayload(), msg::ack));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public CompletionStage receiveMessage(Message msg) {
+        RESULT_DATA.add(msg.getPayload());
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(1, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageNoneAckBean.java
new file mode 100644
index 00000000000..2e00fa07d31
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStageNoneAckBean.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2ComplStageNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public CompletionStage> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return CompletableFuture.completedFuture(msg)
+                .thenApply(m -> Message.of(msg.getPayload()));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public CompletionStage receiveMessage(Message msg) {
+        RESULT_DATA.add(msg.getPayload());
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(1, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStagePrepAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStagePrepAckBean.java
new file mode 100644
index 00000000000..eec3e020569
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2ComplStagePrepAckBean.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2ComplStagePrepAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public CompletionStage> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return CompletableFuture.supplyAsync(() -> Message.of(msg.getPayload(), msg::ack));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public CompletionStage receiveMessage(Message msg) {
+        RESULT_DATA.add(msg.getPayload());
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(1, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgManualAckBean.java
similarity index 89%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgManualAckBean.java
index 4380eb7e3fa..f10c77e2822 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorManualAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgManualAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.processor;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -39,14 +39,17 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ProcessorManualAckBean implements AssertableTestBean {
+public class ProcessorMsg2MsgManualAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
     private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
 
     @Outgoing("inner-processor")
     public Publisher> produceMessage() {
-        return ReactiveStreams.of(Message.of("test-data", () -> ackFuture)).buildRs();
+        return ReactiveStreams.of(Message.of("test-data", () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
     }
 
     @Incoming("inner-processor")
@@ -58,8 +61,8 @@ public Message process(Message msg) {
     }
 
     @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
     public CompletionStage receiveMessage(Message msg) {
-        msg.ack().toCompletableFuture().complete(null);
         return CompletableFuture.completedFuture(null);
     }
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgNoneAckBean.java
new file mode 100644
index 00000000000..432c35cf64d
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgNoneAckBean.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2MsgNoneAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Message process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return msg;
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepExplicitAckBean.java
new file mode 100644
index 00000000000..b654160be3a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepExplicitAckBean.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2MsgPrepExplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public Message process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return Message.of(msg.getPayload());
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepImplicitAckBean.java
new file mode 100644
index 00000000000..08e7810a6d0
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorMsg2MsgPrepImplicitAckBean.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorMsg2MsgPrepImplicitAckBean implements AssertableTestBean {
+
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of("test-data", () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public Message process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return Message.of(msg.getPayload());
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public CompletionStage receiveMessage(Message msg) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessExplicitAckBean.java
similarity index 83%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessExplicitAckBean.java
index e4f3bc8233f..c158ba980cd 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessExplicitAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessExplicitAckBean.java
@@ -15,18 +15,20 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.processor;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.enterprise.context.ApplicationScoped;
 
 import io.helidon.microprofile.messaging.AssertableTestBean;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
@@ -37,9 +39,10 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ProcessorPostProcessExplicitAckBean implements AssertableTestBean {
+public class ProcessorPayl2PaylPostProcessExplicitAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
 
     @Outgoing("inner-processor")
     public Publisher> produceMessage() {
@@ -50,6 +53,7 @@ public Publisher> produceMessage() {
     @Outgoing("inner-consumer")
     @Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
     public String process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
         return msg.toUpperCase();
     }
 
@@ -65,5 +69,6 @@ public void assertValid() {
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
             fail(e);
         }
+        assertFalse(completedBeforeProcessor.get());
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessImplicitAckBean.java
similarity index 78%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessImplicitAckBean.java
index b37b52112c0..dc58f6c6481 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPostProcessImplicitAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPostProcessImplicitAckBean.java
@@ -15,20 +15,23 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.processor;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.enterprise.context.ApplicationScoped;
 
 import io.helidon.microprofile.messaging.AssertableTestBean;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
 import org.eclipse.microprofile.reactive.messaging.Incoming;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.messaging.Outgoing;
@@ -36,9 +39,10 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ProcessorPostProcessImplicitAckBean implements AssertableTestBean {
+public class ProcessorPayl2PaylPostProcessImplicitAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
 
     @Outgoing("inner-processor")
     public Publisher> produceMessage() {
@@ -48,10 +52,12 @@ public Publisher> produceMessage() {
     @Incoming("inner-processor")
     @Outgoing("inner-consumer")
     public String process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
         return msg.toUpperCase();
     }
 
     @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
     public CompletionStage receiveMessage(Message msg) {
         return CompletableFuture.completedFuture(null);
     }
@@ -63,5 +69,6 @@ public void assertValid() {
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
             fail(e);
         }
+        assertFalse(completedBeforeProcessor.get());
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPreProcessAckBean.java
similarity index 94%
rename from microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java
rename to microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPreProcessAckBean.java
index 7ee6a29c20a..284b17e62ce 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/ProcessorPreProcessAckBean.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPayl2PaylPreProcessAckBean.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.messaging.inner.ack;
+package io.helidon.microprofile.messaging.inner.ack.processor;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -39,7 +39,7 @@
 import org.reactivestreams.Publisher;
 
 @ApplicationScoped
-public class ProcessorPreProcessAckBean implements AssertableTestBean {
+public class ProcessorPayl2PaylPreProcessAckBean implements AssertableTestBean {
 
     private CompletableFuture ackFuture = new CompletableFuture<>();
     private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgManualAckBean.java
new file mode 100644
index 00000000000..6abc82656c7
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgManualAckBean.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderMsg2MsgManualAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public ProcessorBuilder, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                });
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgNoneAckBean.java
new file mode 100644
index 00000000000..c54a011a21c
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgNoneAckBean.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderMsg2MsgNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public ProcessorBuilder, Message> process() {
+        return ReactiveStreams.>builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepExplicitAckBean.java
new file mode 100644
index 00000000000..b6d00594c48
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepExplicitAckBean.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderMsg2MsgPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public ProcessorBuilder, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                });
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepImplicitAckBean.java
new file mode 100644
index 00000000000..9af06b34fe2
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderMsg2MsgPrepImplicitAckBean.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderMsg2MsgPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public ProcessorBuilder, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                });
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylNoneAckBean.java
new file mode 100644
index 00000000000..1252d9a7ba6
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylNoneAckBean.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderPayl2PaylNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public ProcessorBuilder process() {
+        return ReactiveStreams.builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylPrepImplicitAckBean.java
new file mode 100644
index 00000000000..52945d13e4a
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorBuilderPayl2PaylPrepImplicitAckBean.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorBuilderPayl2PaylPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public ProcessorBuilder process() {
+        return ReactiveStreams.builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgManualAckBean.java
new file mode 100644
index 00000000000..6d080527af7
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgManualAckBean.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorMsg2MsgManualAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public Processor, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                })
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgNoneAckBean.java
new file mode 100644
index 00000000000..4128feb5617
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgNoneAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorMsg2MsgNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Processor, Message> process() {
+        return ReactiveStreams.>builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()))
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepExplicitAckBean.java
new file mode 100644
index 00000000000..5a8287165a4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepExplicitAckBean.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorMsg2MsgPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public Processor, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                })
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepImplicitAckBean.java
new file mode 100644
index 00000000000..6beb55c2732
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorMsg2MsgPrepImplicitAckBean.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorMsg2MsgPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public Processor, Message> process() {
+        return ReactiveStreams.>builder()
+                .map(m -> {
+                    completedBeforeProcessor.set(ackFuture.isDone());
+                    return Message.of(m.getPayload(), m::ack);
+                })
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylNoneAckBean.java
new file mode 100644
index 00000000000..a242c0eef01
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylNoneAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorPayl2PaylNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Processor process() {
+        return ReactiveStreams.builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()))
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylPrepImplicitAckBean.java
new file mode 100644
index 00000000000..97d3cf7273f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorProcessorPayl2PaylPrepImplicitAckBean.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorProcessorPayl2PaylPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private AtomicReference RESULT_DATA = new AtomicReference<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public Processor process() {
+        return ReactiveStreams.builder()
+                .peek(m -> completedBeforeProcessor.set(ackFuture.isDone()))
+                .buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.set(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(TEST_DATA, RESULT_DATA.get());
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgManualAckBean.java
new file mode 100644
index 00000000000..cea0543e390
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgManualAckBean.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderMsg2MsgManualAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public PublisherBuilder> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        msg.ack();
+        return ReactiveStreams.of(Message.of(msg.getPayload()), Message.of(msg.getPayload()));
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgNoneAckBean.java
new file mode 100644
index 00000000000..cdfe3f745a6
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgNoneAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderMsg2MsgNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public PublisherBuilder> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg);
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepExplicitAckBean.java
new file mode 100644
index 00000000000..e1d97c3be49
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepExplicitAckBean.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderMsg2MsgPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public PublisherBuilder> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg);
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepImplicitAckBean.java
new file mode 100644
index 00000000000..7c1db9b5ab8
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderMsg2MsgPrepImplicitAckBean.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderMsg2MsgPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public PublisherBuilder> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg);
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylNoneAckBean.java
new file mode 100644
index 00000000000..7571253781b
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylNoneAckBean.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderPayl2PaylNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public PublisherBuilder> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        }));
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Publisher process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepExplicitAckBean.java
new file mode 100644
index 00000000000..6560bd71d94
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepExplicitAckBean.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderPayl2PaylPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public PublisherBuilder process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg);
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepImplicitAckBean.java
new file mode 100644
index 00000000000..6e17d7d8829
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherBuilderPayl2PaylPrepImplicitAckBean.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherBuilderPayl2PaylPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public PublisherBuilder process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg);
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgManualAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgManualAckBean.java
new file mode 100644
index 00000000000..1e7789af88f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgManualAckBean.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherMsg2MsgManualAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.MANUAL)
+    public Publisher> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        msg.ack();
+        return ReactiveStreams.of(Message.of(msg.getPayload()), Message.of(msg.getPayload())).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgNoneAckBean.java
new file mode 100644
index 00000000000..deb7191a471
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgNoneAckBean.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherMsg2MsgNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Publisher> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepExplicitAckBean.java
new file mode 100644
index 00000000000..d309fe87c5f
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepExplicitAckBean.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherMsg2MsgPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public Publisher> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepImplicitAckBean.java
new file mode 100644
index 00000000000..b44f0ad5dc4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherMsg2MsgPrepImplicitAckBean.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherMsg2MsgPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public Publisher> process(Message msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylNoneAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylNoneAckBean.java
new file mode 100644
index 00000000000..bf9e835c887
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylNoneAckBean.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherPayl2PaylNoneAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public Publisher process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        assertFalse(ackFuture.isDone());
+        assertFalse(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepExplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepExplicitAckBean.java
new file mode 100644
index 00000000000..5fab5e9d3d4
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepExplicitAckBean.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherPayl2PaylPrepExplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
+    public Publisher process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepImplicitAckBean.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepImplicitAckBean.java
new file mode 100644
index 00000000000..61bbc42e005
--- /dev/null
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/inner/ack/processor/ProcessorPublisherPayl2PaylPrepImplicitAckBean.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.messaging.inner.ack.processor;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.helidon.microprofile.messaging.AssertableTestBean;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.microprofile.reactive.messaging.Acknowledgment;
+import org.eclipse.microprofile.reactive.messaging.Incoming;
+import org.eclipse.microprofile.reactive.messaging.Message;
+import org.eclipse.microprofile.reactive.messaging.Outgoing;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Publisher;
+
+@ApplicationScoped
+public class ProcessorPublisherPayl2PaylPrepImplicitAckBean implements AssertableTestBean {
+
+    public static final String TEST_DATA = "test-data";
+    private CompletableFuture ackFuture = new CompletableFuture<>();
+    private AtomicBoolean completedBeforeProcessor = new AtomicBoolean(false);
+    private CopyOnWriteArrayList RESULT_DATA = new CopyOnWriteArrayList<>();
+
+    @Outgoing("inner-processor")
+    public Publisher> produceMessage() {
+        return ReactiveStreams.of(Message.of(TEST_DATA, () -> {
+            ackFuture.complete(null);
+            return ackFuture;
+        })).buildRs();
+    }
+
+    @Incoming("inner-processor")
+    @Outgoing("inner-consumer")
+    public Publisher process(String msg) {
+        completedBeforeProcessor.set(ackFuture.isDone());
+        return ReactiveStreams.of(msg, msg).buildRs();
+    }
+
+    @Incoming("inner-consumer")
+    @Acknowledgment(Acknowledgment.Strategy.NONE)
+    public void receiveMessage(String msg) {
+        RESULT_DATA.add(msg);
+    }
+
+    @Override
+    public void assertValid() {
+        try {
+            ackFuture.toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+        assertTrue(completedBeforeProcessor.get());
+        assertEquals(2, RESULT_DATA.size());
+        RESULT_DATA.forEach(s -> assertEquals(TEST_DATA, s));
+    }
+}

From 5a0bad25a3d65289c9cabeb5c82f7680f7767777 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 26 Nov 2019 15:34:48 +0100
Subject: [PATCH 28/66] Spot bugs fix

Signed-off-by: Daniel Kec 
---
 .../messaging/kafka/SimpleKafkaConsumer.java  | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
index 391eb6ae3f3..334786102f8 100644
--- a/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
+++ b/messaging/kafka/src/main/java/io/helidon/messaging/kafka/SimpleKafkaConsumer.java
@@ -20,12 +20,11 @@
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentLinkedDeque;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -82,8 +81,8 @@ public class SimpleKafkaConsumer implements Closeable {
     private List topicNameList;
     private KafkaConsumer consumer;
 
-    private final ConcurrentLinkedDeque> backPressureBuffer = new ConcurrentLinkedDeque<>();
-    private CopyOnWriteArrayList> ackFutures = new CopyOnWriteArrayList<>();
+    private final LinkedList> backPressureBuffer = new LinkedList<>();
+    private ArrayList> ackFutures = new ArrayList<>();
 
     /**
      * Kafka consumer created from {@link io.helidon.config.Config config}
@@ -206,12 +205,14 @@ public void cancel() {
                 consumer.subscribe(topicNameList, partitionsAssignedLatch);
                 try {
                     while (!closed.get()) {
-                        waitForAcksAndPoll();
-                        if (backPressureBuffer.isEmpty()) continue;
-                        ConsumerRecord cr = backPressureBuffer.poll();
-                        KafkaMessage kafkaMessage = new KafkaMessage<>(cr);
-                        ackFutures.add(kafkaMessage.getAckFuture());
-                        runInNewContext(() -> subscriber.onNext(kafkaMessage));
+                        synchronized (backPressureBuffer) {
+                            waitForAcksAndPoll();
+                            if (backPressureBuffer.isEmpty()) continue;
+                            ConsumerRecord cr = backPressureBuffer.poll();
+                            KafkaMessage kafkaMessage = new KafkaMessage<>(cr);
+                            ackFutures.add(kafkaMessage.getAckFuture());
+                            runInNewContext(() -> subscriber.onNext(kafkaMessage));
+                        }
                     }
                 } catch (WakeupException ex) {
                     if (!closed.get()) {
@@ -230,18 +231,17 @@ public void cancel() {
      * Wait for the last batch of records to be acknowledged before commit and another poll.
      */
     private void waitForAcksAndPoll() {
-        synchronized (backPressureBuffer) {
-            if (backPressureBuffer.isEmpty()) {
-                try {
-                    if (!ackFutures.isEmpty()) {
-                        CompletableFuture.allOf(ackFutures.toArray(new CompletableFuture[0])).get();
-                        consumer.commitSync();
-                    }
-                    consumer.poll(Duration.ofSeconds(1)).forEach(backPressureBuffer::add);
-                } catch (InterruptedException | ExecutionException e) {
-                    LOGGER.log(Level.SEVERE, "Error when waiting for all polled records acknowledgements.", e);
+        if (backPressureBuffer.isEmpty()) {
+            try {
+                if (!ackFutures.isEmpty()) {
+                    CompletableFuture.allOf(ackFutures.toArray(new CompletableFuture[0])).get();
+                    consumer.commitSync();
                 }
+                consumer.poll(Duration.ofSeconds(1)).forEach(backPressureBuffer::add);
+            } catch (InterruptedException | ExecutionException e) {
+                LOGGER.log(Level.SEVERE, "Error when waiting for all polled records acknowledgements.", e);
             }
+
         }
     }
 

From d7d46b198af20b15120147ff01f7e274215aba73 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 28 Nov 2019 16:06:15 +0100
Subject: [PATCH 29/66] Passing 509/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/FilterProcessor.java      |   4 +
 .../common/reactive/LimitProcessor.java       |   1 +
 .../reactive/CancelSubscriber.java            |  43 +++
 ...etionStage.java => CollectSubscriber.java} |  46 ++-
 .../reactive/ConcatPublisher.java             | 121 ++++++++
 ...rocessor.java => CumulativeProcessor.java} |   4 +-
 .../microprofile/reactive/ExceptionUtils.java |  29 ++
 .../reactive/FailedPublisher.java             |  45 +++
 .../reactive/FindFirstSubscriber.java         |  62 ++++
 .../reactive/FlatMapProcessor.java            |   6 +-
 .../microprofile/reactive/GraphBuilder.java   | 230 +++++++++++++++
 .../reactive/HelidonReactiveStreamEngine.java |  23 +-
 .../reactive/MultiStagesCollector.java        | 232 ---------------
 .../microprofile/reactive/OfPublisher.java    |  55 ++++
 .../reactive/TappedProcessor.java             |  84 ++++++
 .../reactive/ConsumableSubscriber.java        |   2 +-
 .../microrofile/reactive/EngineTest.java      | 272 ++++++++++++++++--
 .../reactive/TestRuntimeException.java        |  26 ++
 .../microrofile/reactive/TestThrowable.java   |  21 ++
 .../tck/HelidonMessagingExtender.java         |  19 --
 ...ile.reactive.messaging.tck.ArchiveExtender |   1 -
 .../tests/tck/tck-reactive-operators/pom.xml  |  79 +++++
 ...e.streams.operators.ReactiveStreamsFactory |  17 ++
 .../reactive/HelidonStreamEngineTckTest.java  |  33 +++
 .../src/test/resources/arquillian.xml         |  30 ++
 25 files changed, 1183 insertions(+), 302 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/{HelidonSubscriberWithCompletionStage.java => CollectSubscriber.java} (74%)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/{HelidonCumulativeProcessor.java => CumulativeProcessor.java} (93%)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
 delete mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestRuntimeException.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestThrowable.java
 delete mode 100644 microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java
 delete mode 100644 microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender
 create mode 100644 microprofile/tests/tck/tck-reactive-operators/pom.xml
 create mode 100644 microprofile/tests/tck/tck-reactive-operators/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory
 create mode 100644 microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
 create mode 100644 microprofile/tests/tck/tck-reactive-operators/src/test/resources/arquillian.xml

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 36bd700db10..a94ad0e2bc1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -21,6 +21,7 @@
 
 /**
  * Processor filtering stream with supplied predicate.
+ *
  * @param  both input/output type
  */
 public class FilterProcessor extends BaseProcessor implements Multi {
@@ -29,6 +30,7 @@ public class FilterProcessor extends BaseProcessor implements Multi
 
     /**
      * Processor filtering stream with supplied predicate.
+     *
      * @param predicate provided predicate to filter stream with
      */
     public FilterProcessor(Predicate predicate) {
@@ -44,6 +46,8 @@ protected void hookOnCancel(Flow.Subscription subscription) {
     protected void hookOnNext(T item) {
         if (predicate.test(item)) {
             submit(item);
+        } else {
+            tryRequest(getSubscription());
         }
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index 61c2c392bd3..60195c5d499 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -56,6 +56,7 @@ protected void hookOnNext(T item) {
             submit(item);
             if (1 < actCounter) {
                 // Don't request after last run
+                getRequestedCounter().increment(1, this::onError);
                 tryRequest(getSubscription());
             } else {
                 tryComplete();
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
new file mode 100644
index 00000000000..03e5d51475e
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+
+public class CancelSubscriber implements Flow.Subscriber {
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    public void onNext(Object item) {
+        System.out.println();
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        // Cancel ignores upstream failures
+    }
+
+    @Override
+    public void onComplete() {
+        System.out.println();
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
similarity index 74%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index bcffec6d4eb..93e25101159 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonSubscriberWithCompletionStage.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -23,6 +23,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
 
 import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
@@ -39,9 +41,13 @@
  *
  * @param  type of streamed item
  */
-public class HelidonSubscriberWithCompletionStage implements SubscriberWithCompletionStage {
+public class CollectSubscriber implements SubscriberWithCompletionStage {
 
     private final Processor connectingProcessor;
+    private final BiConsumer accumulator;
+    private final BinaryOperator combiner;
+    private Object cumulatedVal;
+    private final Function finisher;
     private Subscriber subscriber;
     private CompletableFuture completableFuture = new CompletableFuture<>();
     private Stage.Collect collectStage;
@@ -52,14 +58,17 @@ public class HelidonSubscriberWithCompletionStage implements SubscriberWithCo
      * Subscriber with preceding processors included,
      * automatically makes all downstream subscriptions when its subscribe method is called.
      *
-     * @param collectStage {@link org.eclipse.microprofile.reactive.streams.operators.spi.Stage.Collect}
-     *                     for example {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}
+     * @param collectStage           {@link org.eclipse.microprofile.reactive.streams.operators.spi.Stage.Collect}
+     *                               for example {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}
      * @param precedingProcessorList ordered list of preceding processors(needed for automatic subscription in case of incomplete graph)
      */
     @SuppressWarnings("unchecked")
-    HelidonSubscriberWithCompletionStage(Stage.Collect collectStage,
-                                         List> precedingProcessorList) {
+    CollectSubscriber(Stage.Collect collectStage,
+                      List> precedingProcessorList) {
         this.collectStage = collectStage;
+        accumulator = (BiConsumer) collectStage.getCollector().accumulator();
+        combiner = (BinaryOperator) collectStage.getCollector().combiner();
+        finisher = (Function) collectStage.getCollector().finisher();
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
         subscriber = (Subscriber) prepareSubscriber();
@@ -86,29 +95,44 @@ private Subscriber prepareSubscriber() {
 
             @Override
             public void onSubscribe(Subscription s) {
+                try {
+                    cumulatedVal = collectStage.getCollector().supplier().get();
+                } catch (Throwable t) {
+                    onError(t);
+                    s.cancel();
+                }
                 this.subscription = s;
                 subscription.request(1);
             }
 
             @Override
             @SuppressWarnings("unchecked")
-            public void onNext(Object t) {
+            public void onNext(Object item) {
                 if (!closed.get()) {
-                    BiConsumer accumulator = (BiConsumer) collectStage.getCollector().accumulator();
-                    accumulator.accept(null, t);
-                    subscription.request(1);
+                    try {
+                        accumulator.accept(cumulatedVal, item);
+                        subscription.request(1);
+                    } catch (Throwable t) {
+                        onError(t);
+                        subscription.cancel();
+                    }
                 }
             }
 
             @Override
             public void onError(Throwable t) {
-                throw new RuntimeException(t);
+                completableFuture.completeExceptionally(t);
             }
 
             @Override
+            @SuppressWarnings("unchecked")
             public void onComplete() {
                 closed.set(true);
-                completableFuture.complete(null);
+                try {
+                    completableFuture.complete(finisher.apply(cumulatedVal));
+                } catch (Throwable t) {
+                    onError(t);
+                }
                 subscription.cancel();
             }
         };
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
new file mode 100644
index 00000000000..671a8fd3734
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class ConcatPublisher implements Publisher {
+    private Subscriber subscriber;
+    private Publisher firstPublisher;
+    private Publisher secondPublisher;
+    private TransparentProcessor firstTransparentProcessor;
+
+    public ConcatPublisher(Publisher firstPublisher, Publisher secondPublisher) {
+        this.firstPublisher = firstPublisher;
+        this.secondPublisher = secondPublisher;
+
+    }
+
+    @Override
+    public void subscribe(Subscriber subscriber) {
+        this.subscriber = (Subscriber) subscriber;
+        firstTransparentProcessor = new TransparentProcessor(firstPublisher, secondPublisher);
+
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                firstTransparentProcessor.request(n);
+
+            }
+
+            @Override
+            public void cancel() {
+                firstTransparentProcessor.cancel();
+            }
+        });
+    }
+
+    private class TransparentProcessor implements Processor {
+
+        private Subscription subscription;
+        private boolean isCompleted = false;
+        private AtomicLong requests = new AtomicLong();
+        private TransparentProcessor secondTransparentProcessor;
+
+        private TransparentProcessor() {
+        }
+
+        private TransparentProcessor(Publisher firstPublisher, Publisher secondPublisher) {
+            firstPublisher.subscribe(this);
+            secondTransparentProcessor = new TransparentProcessor();
+            secondPublisher.subscribe(secondTransparentProcessor);
+        }
+
+        @Override
+        public void subscribe(Subscriber subscriber) {
+        }
+
+        @Override
+        public void onSubscribe(Subscription subscription) {
+            this.subscription = subscription;
+        }
+
+        private void request(long n) {
+            requests.set(n);
+            if (!isCompleted) {
+                this.subscription.request(n);
+            } else {
+                secondTransparentProcessor.subscription.request(n);
+            }
+        }
+
+        private void cancel() {
+            this.subscription.cancel();
+            this.secondTransparentProcessor.subscription.cancel();
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onNext(Object t) {
+            requests.decrementAndGet();
+            ConcatPublisher.this.subscriber.onNext((T) t);
+        }
+
+        @Override
+        public void onError(Throwable t) {
+                this.isCompleted = true;
+                ConcatPublisher.this.subscriber.onError(t);
+        }
+
+        @Override
+        public void onComplete() {
+            if (!Objects.isNull(secondTransparentProcessor)) {
+                this.isCompleted = true;
+                this.secondTransparentProcessor.subscription.request(requests.get());
+            } else {
+                ConcatPublisher.this.subscriber.onComplete();
+            }
+        }
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
similarity index 93%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index 9e06561a67d..ed5ed6487c6 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonCumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -30,7 +30,7 @@
 /**
  * {@link org.reactivestreams.Processor} wrapping ordered list of {@link org.reactivestreams.Processor}s.
  */
-public class HelidonCumulativeProcessor implements Processor {
+public class CumulativeProcessor implements Processor {
     private LinkedList> processorList = new LinkedList<>();
 
     /**
@@ -38,7 +38,7 @@ public class HelidonCumulativeProcessor implements Processor {
      *
      * @param precedingProcessorList ordered list of {@link io.helidon.common.reactive.Flow.Processor}s
      */
-    HelidonCumulativeProcessor(List> precedingProcessorList) {
+    CumulativeProcessor(List> precedingProcessorList) {
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
new file mode 100644
index 00000000000..70da09eda72
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+public class ExceptionUtils {
+
+    public static void throwUncheckedException(Throwable t) {
+        ExceptionUtils.throwWithTypeErasure(t);
+    }
+
+    private static  void throwWithTypeErasure(Throwable t) throws T {
+        throw (T) t;
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
new file mode 100644
index 00000000000..e06a12414d5
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+
+public class FailedPublisher implements Flow.Publisher {
+
+    private Throwable throwable;
+
+    public FailedPublisher(Throwable throwable) {
+        this.throwable = throwable;
+    }
+
+    @Override
+    public void subscribe(Flow.Subscriber subscriber) {
+        subscriber.onError(throwable);
+        subscriber.onSubscribe(new Flow.Subscription() {
+            @Override
+            public void request(long n) {
+
+            }
+
+            @Override
+            public void cancel() {
+
+            }
+        });
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
new file mode 100644
index 00000000000..4fd88c69674
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+import io.helidon.common.reactive.Flow;
+
+public class FindFirstSubscriber implements Flow.Subscriber {
+    private Flow.Subscription subscription;
+    private CompletableFuture completionStage = new CompletableFuture<>();
+    private Optional firstItem = Optional.empty();
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        this.subscription = subscription;
+        this.subscription.request(1);
+    }
+
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onNext(Object item) {
+        subscription.cancel();
+        Object optItem = (Object) Optional.of(item);
+        completionStage.complete(optItem);
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        ExceptionUtils.throwUncheckedException(throwable);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onComplete() {
+        Object optItem = (Object) Optional.empty();
+        completionStage.complete(optItem);
+    }
+
+
+    public CompletionStage getCompletion() {
+        return completionStage;
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 05bc688e8d6..c77b5760886 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -37,6 +37,7 @@ public class FlatMapProcessor extends BaseProcessor implements M
 
     /**
      * Flatten the elements emitted by publishers produced by the mapper function to this stream.
+     *
      * @param mapper publisher to flatten his data to this stream
      */
     @SuppressWarnings("unchecked")
@@ -52,7 +53,10 @@ protected void hookOnNext(Object item) {
         try {
             ReactiveStreams
                     .fromPublisher(publisher)
-                    .forEach(this::submit)
+                    .forEach(i -> {
+                        this.getRequestedCounter().increment(1L, this::onError);
+                        this.submit(i);
+                    })
                     .run().toCompletableFuture().get();
         } catch (InterruptedException | ExecutionException e) {
             onError(e);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
new file mode 100644
index 00000000000..dafe059c5cb
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.LimitProcessor;
+import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.MultiMappingProcessor;
+import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
+import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
+import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
+import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+public final class GraphBuilder extends HashMap, Consumer> {
+
+    private Multi multi = null;
+    private List> processorList = new ArrayList<>();
+    private CompletionStage completionStage = null;
+    private CollectSubscriber subscriberWithCompletionStage = null;
+
+    @SuppressWarnings("unchecked")
+    private GraphBuilder() {
+        registerStage(Stage.PublisherStage.class, stage -> {
+            multi = MultiRS.toMulti((Publisher) stage.getRsPublisher());
+        });
+        registerStage(Stage.Concat.class, stage -> {
+            HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
+            Publisher firstPublisher = streamEngine.buildPublisher(stage.getFirst());
+            Publisher secondPublisher = streamEngine.buildPublisher(stage.getSecond());
+            multi = MultiRS.toMulti(new ConcatPublisher<>(firstPublisher, secondPublisher));
+        });
+        registerStage(Stage.Of.class, stage -> {
+            multi = Multi.from(new OfPublisher(stage.getElements()));
+        });
+        registerStage(Stage.Failed.class, stage -> {
+            multi = Multi.from(new FailedPublisher(stage.getError()));
+        });
+        registerStage(Stage.Map.class, stage -> {
+            Function mapper = (Function) stage.getMapper();
+            processorList.add(new MultiMappingProcessor<>(mapper::apply));
+        });
+        registerStage(Stage.Filter.class, stage -> {
+            processorList.add(new FilterProcessor(stage.getPredicate()));
+        });
+        registerStage(Stage.Peek.class, stage -> {
+            Consumer peekConsumer = (Consumer) stage.getConsumer();
+            processorList.add(new PeekProcessor<>(peekConsumer));
+        });
+        registerStage(Stage.Limit.class, stage -> {
+            processorList.add(new LimitProcessor(stage.getLimit()));
+        });
+        registerStage(Stage.FlatMap.class, stage -> {
+            processorList.add(new FlatMapProcessor(stage.getMapper()));
+        });
+        registerStage(Stage.OnTerminate.class, stage -> {
+            processorList.add(TappedProcessor.create()
+                    .onComplete(stage.getAction())
+                    .onCancel((s) -> stage.getAction().run())
+                    .onError((t) -> stage.getAction().run()));
+        });
+        registerStage(Stage.Cancel.class, stage -> {
+            CancelSubscriber cancelSubscriber = new CancelSubscriber();
+            subscribeUpStream();
+            multi.subscribe(cancelSubscriber);
+            this.completionStage = CompletableFuture.completedFuture(null);
+        });
+        registerStage(Stage.FindFirst.class, stage -> {
+            FindFirstSubscriber firstSubscriber = new FindFirstSubscriber<>();
+            subscribeUpStream();
+            multi.subscribe(firstSubscriber);
+            this.completionStage = firstSubscriber.getCompletion();
+        });
+        registerStage(Stage.SubscriberStage.class, stage -> {
+            Subscriber subscriber = (Subscriber) stage.getRsSubscriber();
+            this.completionStage = new CompletableFuture<>();
+            RedeemingCompletionSubscriber completionSubscriber =
+                    RedeemingCompletionSubscriber.of(subscriber, completionStage);
+            // If producer was supplied
+            subscribeUpStream();
+            multi.subscribe(HybridSubscriber.from(completionSubscriber));
+        });
+        registerStage(Stage.Collect.class, stage -> {
+            // Foreach
+            this.subscriberWithCompletionStage = new CollectSubscriber(stage, processorList);
+            // If producer was supplied
+            if (multi != null) {
+                multi.subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
+            }
+        });
+    }
+
+    public static GraphBuilder create() {
+        return new GraphBuilder();
+    }
+
+    public GraphBuilder from(Graph graph) {
+        graph.getStages().forEach(this::add);
+        return this;
+    }
+
+    public GraphBuilder add(Stage stage) {
+        Consumer stageConsumer = this.get(stage.getClass());
+
+        this.keySet()
+                .stream()
+                .filter(c -> c.isAssignableFrom(stage.getClass()))
+                .map(this::get)
+                .findFirst()
+                .orElseThrow(() -> new UnsupportedStageException(stage))
+                .accept(stage);
+
+        return this;
+    }
+
+    /**
+     * Return subscriber from even incomplete graph,
+     * in case of incomplete graph does subscriptions downstream automatically in the
+     * {@link CollectSubscriber}.
+     *
+     * @param  type of items subscriber consumes
+     * @param  type of items subscriber emits
+     * @return {@link org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage}
+     */
+    @SuppressWarnings("unchecked")
+     SubscriberWithCompletionStage getSubscriberWithCompletionStage() {
+        return (SubscriberWithCompletionStage) subscriberWithCompletionStage;
+    }
+
+    /**
+     * Return {@link java.util.concurrent.CompletionStage}
+     * either from supplied {@link org.reactivestreams.Subscriber}
+     * for example by {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}
+     * or from completion stage for example
+     * {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}.
+     *
+     * @param  type of items subscriber consumes
+     * @return {@link CollectSubscriber}
+     */
+    @SuppressWarnings("unchecked")
+     CompletionStage getCompletionStage() {
+        return (CompletionStage) (completionStage != null ? completionStage : subscriberWithCompletionStage.getCompletion());
+    }
+
+    /**
+     * Return {@link org.reactivestreams.Processor} wrapping all processor stages from processor builder.
+     * 
    See example:
+     * 
    {@code
+     *   Processor processor = ReactiveStreams.builder()
+     *       .map(i -> i + 1)
+     *       .flatMap(i -> ReactiveStreams.of(i, i))
+     *       .map(i -> Integer.toString(i))
+     *       .buildRs();
+     * }
    
+     *
+     * @param  type of items subscriber consumes
+     * @param  type of items subscriber emits
+     * @return {@link org.reactivestreams.Processor} wrapping all processor stages
+     */
+    @SuppressWarnings("unchecked")
+     Processor getProcessor() {
+        return (Processor) new CumulativeProcessor(processorList);
+    }
+
+    /**
+     * Returns {@link org.reactivestreams.Publisher} made from supplied stages.
+     * 
    See example:
+     * 
    {@code
+     *   ReactiveStreams
+     *      .of("10", "20", "30")
+     *      .map(a -> a.replaceAll("0", ""))
+     *      .map(Integer::parseInt)
+     *      .buildRs()
+     * }
    
+     *
+     * @return {@link org.reactivestreams.Publisher}
+     */
+    @SuppressWarnings("unchecked")
+     Publisher getPublisher() {
+        subscribeUpStream();
+        return (Publisher) MultiRS.from(multi);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void subscribeUpStream() {
+        if (multi != null) {
+            for (Flow.Processor p : processorList) {
+                multi.subscribe(p);
+                multi = (Multi) p;
+            }
+        } else {
+            throw new RuntimeException("No producer was supplied");
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private  GraphBuilder registerStage(Class stageType, Consumer consumer) {
+        this.put(stageType, (Consumer) consumer);
+        return this;
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
index 50c1d65cf42..3c9cf5b786e 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/HelidonReactiveStreamEngine.java
@@ -18,13 +18,10 @@
 package io.helidon.microprofile.reactive;
 
 
-import java.util.Collection;
 import java.util.concurrent.CompletionStage;
-import java.util.logging.Logger;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.ReactiveStreamsEngine;
-import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
 import org.reactivestreams.Processor;
@@ -38,40 +35,28 @@
  */
 public class HelidonReactiveStreamEngine implements ReactiveStreamsEngine {
 
-    private static final Logger LOGGER = Logger.getLogger(HelidonReactiveStreamEngine.class.getName());
-
     @Override
     @SuppressWarnings("unchecked")
     public  Publisher buildPublisher(Graph graph) throws UnsupportedStageException {
-        MultiStagesCollector multiStagesCollector = new MultiStagesCollector<>();
-        Collection stages = graph.getStages();
-        stages.stream().collect(multiStagesCollector);
-        return multiStagesCollector.getPublisher();
+        return GraphBuilder.create().from(graph).getPublisher();
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public  SubscriberWithCompletionStage buildSubscriber(Graph graph) throws UnsupportedStageException {
-        MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
-        graph.getStages().stream().collect(multiStagesCollector);
-        return multiStagesCollector.getSubscriberWithCompletionStage();
+        return GraphBuilder.create().from(graph).getSubscriberWithCompletionStage();
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public  Processor buildProcessor(Graph graph) throws UnsupportedStageException {
-        MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
-        graph.getStages().stream().collect(multiStagesCollector);
-        return multiStagesCollector.getProcessor();
+        return GraphBuilder.create().from(graph).getProcessor();
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public  CompletionStage buildCompletion(Graph graph) throws UnsupportedStageException {
-        MultiStagesCollector multiStagesCollector = new MultiStagesCollector();
-        graph.getStages().stream().collect(multiStagesCollector);
-        CompletionStage completionStage = (CompletionStage) multiStagesCollector.getCompletionStage();
-        return completionStage;
+        return GraphBuilder.create().from(graph).getCompletionStage();
     }
 }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
deleted file mode 100644
index a62fb277e69..00000000000
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiStagesCollector.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.reactive;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
-
-import io.helidon.common.reactive.FilterProcessor;
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.LimitProcessor;
-import io.helidon.common.reactive.Multi;
-import io.helidon.common.reactive.MultiMappingProcessor;
-import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
-
-import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
-import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
-import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
-import org.eclipse.microprofile.reactive.streams.operators.spi.UnsupportedStageException;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
-
-/**
- * Collect {@link org.reactivestreams Reactive Streams}
- * {@link org.eclipse.microprofile.reactive.streams.operators.spi.Stage Stages}
- * to {@link org.reactivestreams.Publisher}, {@link org.reactivestreams.Processor}
- * or {@link org.reactivestreams.Subscriber}.
- *
- * @param 
- */
-class MultiStagesCollector implements Collector, CompletionStage> {
-
-    private Multi multi = null;
-    private List> processorList = new ArrayList<>();
-    private CompletionStage completionStage = null;
-    private HelidonSubscriberWithCompletionStage subscriberWithCompletionStage = null;
-
-    @Override
-    public Supplier> supplier() {
-        return () -> multi != null ? multi : Multi.empty();
-    }
-
-    @SuppressWarnings("unchecked")
-    private void subscribeUpStream() {
-        if (multi != null) {
-            for (Flow.Processor p : processorList) {
-                multi.subscribe(p);
-                multi = (Multi) p;
-            }
-        } else {
-            throw new RuntimeException("No producer was supplied");
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public BiConsumer, Stage> accumulator() {
-        //MP Stages to Helidon multi streams mapping
-        return (m, stage) -> {
-
-            if (stage instanceof Stage.PublisherStage) {
-                Stage.PublisherStage publisherStage = (Stage.PublisherStage) stage;
-                Publisher rsPublisher = (Publisher) publisherStage.getRsPublisher();
-                multi = MultiRS.toMulti(rsPublisher);
-
-            } else if (stage instanceof Stage.Of) {
-                Stage.Of stageOf = (Stage.Of) stage;
-                List fixedData = StreamSupport.stream(stageOf.getElements().spliterator(), false)
-                        .collect(Collectors.toList());
-                multi = (Multi) Multi.just(fixedData);
-
-            } else if (stage instanceof Stage.Map) {
-                Stage.Map mapStage = (Stage.Map) stage;
-                Function mapper = (Function) mapStage.getMapper();
-                processorList.add(new MultiMappingProcessor<>(mapper::apply));
-
-            } else if (stage instanceof Stage.Filter) {
-                Stage.Filter stageFilter = (Stage.Filter) stage;
-                Predicate predicate = (Predicate) stageFilter.getPredicate();
-                processorList.add(new FilterProcessor(predicate));
-
-            } else if (stage instanceof Stage.Peek) {
-                Stage.Peek peekStage = (Stage.Peek) stage;
-                Consumer peekConsumer = (Consumer) peekStage.getConsumer();
-                processorList.add(new PeekProcessor(peekConsumer));
-
-            } else if (stage instanceof Stage.Limit) {
-                Stage.Limit limitStage = (Stage.Limit) stage;
-                processorList.add(new LimitProcessor(limitStage.getLimit()));
-
-            } else if (stage instanceof Stage.FlatMap) {
-                Stage.FlatMap flatMapStage = (Stage.FlatMap) stage;
-                Function mapper = flatMapStage.getMapper();
-                processorList.add(new FlatMapProcessor(mapper));
-
-            } else if (stage instanceof Stage.SubscriberStage) {
-                Stage.SubscriberStage subscriberStage = (Stage.SubscriberStage) stage;
-                Subscriber subscriber = (Subscriber) subscriberStage.getRsSubscriber();
-                this.completionStage = new CompletableFuture<>();
-                RedeemingCompletionSubscriber completionSubscriber =
-                        RedeemingCompletionSubscriber.of(subscriber, completionStage);
-                // If producer was supplied
-                subscribeUpStream();
-                multi.subscribe(HybridSubscriber.from(completionSubscriber));
-
-            } else if (stage instanceof Stage.Collect) {
-                // Foreach
-                Stage.Collect collectStage = (Stage.Collect) stage;
-                this.subscriberWithCompletionStage = new HelidonSubscriberWithCompletionStage<>(collectStage, processorList);
-                // If producer was supplied
-                if (multi != null) {
-                    multi.subscribe(HybridSubscriber.from(subscriberWithCompletionStage.getSubscriber()));
-                }
-
-            } else {
-                throw new UnsupportedStageException(stage);
-            }
-        };
-    }
-
-    @Override
-    public BinaryOperator> combiner() {
-        return (a, b) -> null;
-    }
-
-    @Override
-    public Function, CompletionStage> finisher() {
-        return t -> getCompletionStage();
-    }
-
-    @Override
-    public Set characteristics() {
-        return new HashSet<>(Collections.singletonList(Characteristics.IDENTITY_FINISH));
-    }
-
-    /**
-     * Return subscriber from even incomplete graph,
-     * in case of incomplete graph does subscriptions downstream automatically in the
-     * {@link io.helidon.microprofile.reactive.HelidonSubscriberWithCompletionStage}.
-     *
-     * @param  type of items subscriber consumes
-     * @param  type of items subscriber emits
-     * @return {@link org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage}
-     */
-    @SuppressWarnings("unchecked")
-     SubscriberWithCompletionStage getSubscriberWithCompletionStage() {
-        return (SubscriberWithCompletionStage) subscriberWithCompletionStage;
-    }
-
-    /**
-     * Return {@link java.util.concurrent.CompletionStage}
-     * either from supplied {@link org.reactivestreams.Subscriber}
-     * for example by {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}
-     * or from completion stage for example
-     * {@link org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder#forEach(java.util.function.Consumer)}.
-     *
-     * @param  type of items subscriber consumes
-     * @return {@link io.helidon.microprofile.reactive.HelidonSubscriberWithCompletionStage}
-     */
-    @SuppressWarnings("unchecked")
-     CompletionStage getCompletionStage() {
-        return (CompletionStage) (completionStage != null ? completionStage : subscriberWithCompletionStage.getCompletion());
-    }
-
-    /**
-     * Return {@link org.reactivestreams.Processor} wrapping all processor stages from processor builder.
-     * 
    See example:
-     * 
    {@code
-     *   Processor processor = ReactiveStreams.builder()
-     *       .map(i -> i + 1)
-     *       .flatMap(i -> ReactiveStreams.of(i, i))
-     *       .map(i -> Integer.toString(i))
-     *       .buildRs();
-     * }
    
-     *
-     * @param  type of items subscriber consumes
-     * @param  type of items subscriber emits
-     * @return {@link org.reactivestreams.Processor} wrapping all processor stages
-     */
-    @SuppressWarnings("unchecked")
-     Processor getProcessor() {
-        return (Processor) new HelidonCumulativeProcessor(processorList);
-    }
-
-    /**
-     * Returns {@link org.reactivestreams.Publisher} made from supplied stages.
-     * 
    See example:
-     * 
    {@code
-     *   ReactiveStreams
-     *      .of("10", "20", "30")
-     *      .map(a -> a.replaceAll("0", ""))
-     *      .map(Integer::parseInt)
-     *      .buildRs()
-     * }
    
-     *
-     * @return {@link org.reactivestreams.Publisher}
-     */
-    Publisher getPublisher() {
-        subscribeUpStream();
-        return MultiRS.from(multi);
-    }
-}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
new file mode 100644
index 00000000000..8c717231182
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import io.helidon.common.reactive.Flow;
+
+public class OfPublisher implements Flow.Publisher {
+    private Iterable iterable;
+    private AtomicBoolean cancelled = new AtomicBoolean(false);
+
+    public OfPublisher(Iterable iterable) {
+        this.iterable = iterable;
+    }
+
+    @Override
+    public void subscribe(Flow.Subscriber subscriber) {
+        final Iterator iterator = iterable.iterator();
+        subscriber.onSubscribe(new Flow.Subscription() {
+            @Override
+            public void request(long n) {
+                for (long i = 0; i < n; i++) {
+                    if (iterator.hasNext() && !cancelled.get()) {
+                        subscriber.onNext(iterator.next());
+                    } else {
+                        subscriber.onComplete();
+                    }
+                }
+            }
+
+            @Override
+            public void cancel() {
+                cancelled.set(true);
+            }
+        });
+    }
+
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
new file mode 100644
index 00000000000..8509f6c5c1f
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import io.helidon.common.reactive.BaseProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
+
+public class TappedProcessor extends BaseProcessor implements Multi {
+
+    private Optional> onNextFunction = Optional.empty();
+    private Optional> onErrorConsumer = Optional.empty();
+    private Optional onCompleteRunnable = Optional.empty();
+    private Optional> onCancelConsumer = Optional.empty();
+
+    private TappedProcessor() {
+    }
+
+    public static TappedProcessor create() {
+        return new TappedProcessor();
+    }
+
+    public TappedProcessor onNext(Function function) {
+        onNextFunction = Optional.ofNullable(function);
+        return this;
+    }
+
+    public TappedProcessor onError(Consumer consumer) {
+        onErrorConsumer = Optional.ofNullable(consumer);
+        return this;
+    }
+
+    public TappedProcessor onComplete(Runnable runnable) {
+        onCompleteRunnable = Optional.ofNullable(runnable);
+        return this;
+    }
+
+    public TappedProcessor onCancel(Consumer consumer) {
+        onCancelConsumer = Optional.ofNullable(consumer);
+        return this;
+    }
+
+    @Override
+    protected void hookOnNext(Object item) {
+        submit(onNextFunction.map(f -> f.apply(item)).orElse(item));
+    }
+
+    @Override
+    protected void hookOnError(Throwable error) {
+        onErrorConsumer.ifPresent(c -> c.accept(error));
+        super.hookOnError(error);
+    }
+
+    @Override
+    protected void hookOnComplete() {
+        onCompleteRunnable.ifPresent(Runnable::run);
+        super.hookOnComplete();
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        onCancelConsumer.ifPresent(c -> c.accept(subscription));
+        subscription.cancel();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
index 94ce51a09f5..7d09b381243 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConsumableSubscriber.java
@@ -43,7 +43,7 @@ public ConsumableSubscriber(Consumer onNext, long requestCount) {
     public void onSubscribe(Subscription s) {
         this.subscription = s;
         //First chunk request
-        subscription.request(requestCount.get());
+        subscription.request(requestCount.decrementAndGet());
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 2aabd5a35f3..423e04c533a 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -17,20 +17,34 @@
 
 package io.helidon.microrofile.reactive;
 
-import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
-import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.junit.jupiter.api.Test;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.StringJoiner;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscription;
+
 public class EngineTest {
     @Test
     void fixedItemsWithMap() {
@@ -62,7 +76,7 @@ void publisherWithMapAndPeekAndFilter() {
 
         ReactiveStreams.fromPublisher(intSequencePublisher)
                 .limit(10)
-                .filter(x -> (x % 2) == 0)
+                .filter(x -> x % 2 == 0)
                 .peek(peekSum::addAndGet)
                 .map(String::valueOf)
                 .map(s -> s + "0")
@@ -87,13 +101,14 @@ void fromTo() throws ExecutionException, InterruptedException, TimeoutException
                 .peek(beforeFilter::append)
                 .map(s -> s.replaceAll("-", ""))
                 .map(Integer::parseInt)
-                .filter(i -> i <= 5)
+                .filter(i -> i % 2 == 0)
                 .peek(afterFilter::append)
+                .limit(5L)
                 .to(ReactiveStreams.fromSubscriber(new ConsumableSubscriber<>(sum::addAndGet, 10)))
                 .run();
         assertEquals("1-2-3-4-5-6-7-8-9-10-", beforeFilter.toString());
-        assertEquals("12345", afterFilter.toString());
-        assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
+        assertEquals("246810", afterFilter.toString());
+        assertEquals(2 + 4 + 6 + 8 + 10, sum.get());
     }
 
     @Test
@@ -112,16 +127,19 @@ void limit() {
     }
 
     @Test
-    void subscriberCreation() throws ExecutionException, InterruptedException {
+    void subscriberCreation() throws ExecutionException, InterruptedException, TimeoutException {
+        AtomicInteger peekedSum = new AtomicInteger();
         AtomicInteger sum = new AtomicInteger();
         IntSequencePublisher publisher = new IntSequencePublisher();
         CompletionSubscriber subscriber = ReactiveStreams.builder()
                 .limit(5)
-                .peek(System.out::println)
+                .peek(peekedSum::addAndGet)
                 .forEach(sum::addAndGet)
                 .build();
         publisher.subscribe(subscriber);
+        subscriber.getCompletion().toCompletableFuture().get(1, TimeUnit.SECONDS);
         assertEquals(1 + 2 + 3 + 4 + 5, sum.get());
+        assertEquals(1 + 2 + 3 + 4 + 5, peekedSum.get());
     }
 
     @Test
@@ -143,7 +161,6 @@ void processorBuilder() {
 
         publisherBuilder.subscribe(processor);
         processor.subscribe(HybridSubscriber.from(subscriber));
-
         assertEquals("1122334455667788991010", stringBuffer.toString());
     }
 
@@ -153,10 +170,10 @@ void ofForEach() throws ExecutionException, InterruptedException {
         ReactiveStreams
                 .of(3, 4)
                 .forEach(sum::addAndGet)
-                .run();
-                //.toCompletableFuture().get();
+                .run().toCompletableFuture().get();
         assertEquals(3 + 4, sum.get());
     }
+
     @Test
     void publisherToForEach() {
         AtomicInteger sum = new AtomicInteger();
@@ -167,4 +184,227 @@ void publisherToForEach() {
                 .run();
         assertEquals(3 + 4, sum.get());
     }
+
+    @Test
+    void concat() throws InterruptedException, ExecutionException, TimeoutException {
+        final List resultList = new ArrayList<>();
+        ReactiveStreams
+                .concat(ReactiveStreams.of(1, 2, 3),
+                        ReactiveStreams.of(4, 5, 6))
+                .forEach(resultList::add).run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), resultList);
+    }
+
+    @Test
+    void complStage() throws InterruptedException, ExecutionException, TimeoutException {
+        final List resultList = new ArrayList<>();
+        CompletionStage run = ReactiveStreams.of(1, 2, 3)
+                .forEach(resultList::add).run();
+        run.toCompletableFuture().get(2, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(1, 2, 3), resultList);
+    }
+
+    @Test
+    void collect() throws ExecutionException, InterruptedException {
+        assertEquals(ReactiveStreams.of(1, 2, 3)
+                .collect(() -> new AtomicInteger(0), AtomicInteger::addAndGet
+                ).run().toCompletableFuture().get().get(), 6);
+    }
+
+    @Test
+    void cancel() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage result = ReactiveStreams.fromPublisher(s -> s.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+                cancelled.complete(null);
+            }
+        }))
+                .cancel()
+                .run();
+
+        cancelled.get(1, TimeUnit.SECONDS);
+        result.toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void cancelWithFailures() {
+        ReactiveStreams
+                .failed(new TestThrowable())
+                .cancel()
+                .run();
+    }
+
+    @Test
+    void findFirst() throws InterruptedException, ExecutionException, TimeoutException {
+        Optional result = ReactiveStreams
+                .of(1, 2, 3)
+                .findFirst()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+
+        assertEquals(Integer.valueOf(1), result.get());
+    }
+
+    @Test
+    void failed() {
+        assertThrows(TestThrowable.class, () -> ReactiveStreams
+                .failed(new TestThrowable())
+                .findFirst()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void finisherTest() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals("1, 2, 3", ReactiveStreams
+                .of("1", "2", "3")
+                .collect(Collectors.joining(", "))
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void collectorExceptionPropagation() {
+        //supplier
+        assertThrows(ExecutionException.class, () -> ReactiveStreams.of("1", "2", "3")
+                .collect(Collector.of(
+                        () -> {
+                            throw new TestRuntimeException();
+                        },
+                        StringJoiner::add,
+                        StringJoiner::merge,
+                        StringJoiner::toString
+                ))
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+        //accumulator
+        assertThrows(ExecutionException.class, () -> ReactiveStreams.of("1", "2", "3")
+                .collect(Collector.of(
+                        () -> new StringJoiner(","),
+                        (s, t) -> {
+                            throw new TestRuntimeException();
+                        },
+                        StringJoiner::merge,
+                        StringJoiner::toString
+                ))
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+
+        //finisher
+        assertThrows(ExecutionException.class, () -> ReactiveStreams.of("1", "2", "3")
+                .collect(Collector.of(
+                        () -> new StringJoiner(","),
+                        StringJoiner::add,
+                        StringJoiner::merge,
+                        f -> {
+                            throw new TestRuntimeException();
+                        }
+                ))
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
+
+    @Test
+    void onTerminate() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture terminator = new CompletableFuture<>();
+        ReactiveStreams
+                .of("1", "2", "3")
+                .onTerminate(() -> terminator.complete(null))
+                .collect(Collectors.joining(", "))
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        terminator.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void publisherWithTerminate() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture terminator = new CompletableFuture<>();
+        Publisher publisher = ReactiveStreams.of(1, 2, 3)
+                .onTerminate(() -> {
+                    terminator.complete(null);
+                })
+                .buildRs();
+
+        Optional result = ReactiveStreams.fromPublisher(publisher)
+                .findFirst().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        assertEquals(1, result.get());
+        terminator.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture outerCancelled = new CompletableFuture<>();
+        CompletableFuture innerCancelled = new CompletableFuture<>();
+        ReactiveStreams.of("1", "2", "3", "1", "2", "3")
+                .onTerminate(() -> outerCancelled.complete(null))
+                .flatMap((i) -> ReactiveStreams.of("1", "2", "3", "1", "2", "3")
+                        .onTerminate(() -> innerCancelled.complete(null))
+                )
+                .limit(5L)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(2, TimeUnit.SECONDS);
+        innerCancelled.get(1, TimeUnit.SECONDS);
+        outerCancelled.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void concatCancel() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage completion = ReactiveStreams
+                .concat(
+                        ReactiveStreams.failed(new TestRuntimeException()),
+                        ReactiveStreams.of(1, 2, 3)
+                                .onTerminate(() -> {
+                                    cancelled.complete(null);
+                                })
+                )
+                .ignore()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> completion.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
+    @Test
+    void filter() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletionStage> cs = ReactiveStreams.of(1, 2, 3, 4, 5, 6)
+                .filter((i) -> {
+                    return (i & 1) == 1;
+                }).toList()
+                .run();
+        assertEquals(Arrays.asList(1, 3, 5), cs.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    //@Test
+    void cancellationException() throws InterruptedException, ExecutionException, TimeoutException {
+        assertThrows(CancellationException.class, () -> ReactiveStreams.fromPublisher(subscriber -> subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+            }
+        })).to(
+                ReactiveStreams.builder().cancel().build()
+        ).run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    //@Test
+    void publisherToSubscriber() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletionSubscriber> subscriber = ReactiveStreams.builder()
+                .limit(5L)
+                .findFirst()
+                .build();
+        assertEquals(1, ReactiveStreams.of(1, 2, 3)
+                .to(subscriber)
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS));
+
+    }
 }
\ No newline at end of file
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestRuntimeException.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestRuntimeException.java
new file mode 100644
index 00000000000..60e1f840da1
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestRuntimeException.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+public class TestRuntimeException extends RuntimeException {
+    public static final String TEST_MSG = TestRuntimeException.class.getSimpleName();
+
+    public TestRuntimeException() {
+        super(TEST_MSG);
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestThrowable.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestThrowable.java
new file mode 100644
index 00000000000..4062cbbf82c
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TestThrowable.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+public class TestThrowable extends Throwable {
+}
diff --git a/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java b/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java
deleted file mode 100644
index fc67531f19b..00000000000
--- a/microprofile/tests/tck/tck-messaging/src/main/java/io/smallrye/reactive/messaging/tck/HelidonMessagingExtender.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package io.smallrye.reactive.messaging.tck;
-
-import javax.enterprise.inject.spi.Extension;
-
-import io.helidon.microprofile.messaging.MessagingCdiExtension;
-import org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender;
-import org.jboss.shrinkwrap.api.asset.EmptyAsset;
-import org.jboss.shrinkwrap.api.spec.JavaArchive;
-
-
-public class HelidonMessagingExtender implements ArchiveExtender {
-    @Override
-    public void extend(JavaArchive archive) {
-        archive
-                .addPackages(true, MessagingCdiExtension.class.getPackage())
-                .addAsServiceProvider(Extension.class, MessagingCdiExtension.class)
-                .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
-    }
-}
diff --git a/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender b/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender
deleted file mode 100644
index 744b174b823..00000000000
--- a/microprofile/tests/tck/tck-messaging/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.messaging.tck.ArchiveExtender
+++ /dev/null
@@ -1 +0,0 @@
-io.smallrye.reactive.messaging.tck.HelidonMessagingExtender
diff --git a/microprofile/tests/tck/tck-reactive-operators/pom.xml b/microprofile/tests/tck/tck-reactive-operators/pom.xml
new file mode 100644
index 00000000000..7a80c525b05
--- /dev/null
+++ b/microprofile/tests/tck/tck-reactive-operators/pom.xml
@@ -0,0 +1,79 @@
+
+
+
+
+    4.0.0
+    
+        io.helidon.microprofile.tests
+        tck-project
+        1.3.2-SNAPSHOT
+    
+    tck-reactive-operators
+    Helidon Microprofile Tests TCK Reactive Streams Operators
+
+    
+        
+            io.helidon.microprofile.tests
+            helidon-arquillian
+            ${project.version}
+            test
+            
+                
+                    io.helidon.microprofile.bundles
+                    helidon-microprofile-3.1
+                
+            
+        
+        
+            io.helidon.microprofile
+            helidon-microprofile-reactive-streams
+            1.3.2-SNAPSHOT
+        
+
+        
+            org.eclipse.microprofile.reactive-streams-operators
+            microprofile-reactive-streams-operators-tck
+            1.0
+        
+    
+
+    
+        
+            
+                org.apache.maven.plugins
+                maven-surefire-plugin
+                false
+                
+                    
+                        org.eclipse.microprofile.reactive.messaging:microprofile-reactive-messaging-tck
+                        
+                    
+                
+                
+                    
+                        org.apache.maven.surefire
+                        surefire-junit4
+                        ${version.plugin.surefire}
+                    
+                
+            
+        
+    
+
diff --git a/microprofile/tests/tck/tck-reactive-operators/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory b/microprofile/tests/tck/tck-reactive-operators/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory
new file mode 100644
index 00000000000..8e4c3a64b7e
--- /dev/null
+++ b/microprofile/tests/tck/tck-reactive-operators/src/main/resources/META-INF/services/org.eclipse.microprofile.reactive.streams.operators.ReactiveStreamsFactory
@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+#
+# 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.
+#
+
+org.eclipse.microprofile.reactive.streams.operators.core.ReactiveStreamsFactoryImpl
\ No newline at end of file
diff --git a/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
new file mode 100644
index 00000000000..a5a9537b5da
--- /dev/null
+++ b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.tck.ReactiveStreamsTck;
+import org.reactivestreams.tck.TestEnvironment;
+
+public class HelidonStreamEngineTckTest extends ReactiveStreamsTck {
+
+    public HelidonStreamEngineTckTest() {
+        super(new TestEnvironment());
+    }
+
+    @Override
+    protected HelidonReactiveStreamEngine createEngine() {
+        return new HelidonReactiveStreamEngine();
+    }
+}
diff --git a/microprofile/tests/tck/tck-reactive-operators/src/test/resources/arquillian.xml b/microprofile/tests/tck/tck-reactive-operators/src/test/resources/arquillian.xml
new file mode 100644
index 00000000000..45075f08eb0
--- /dev/null
+++ b/microprofile/tests/tck/tck-reactive-operators/src/test/resources/arquillian.xml
@@ -0,0 +1,30 @@
+
+
+
+
+
+    
+        target/deployments
+        -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y
+
+

From bd572c6339cd1dd518e885fa6a1e430b3f9342cc Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 29 Nov 2019 11:57:58 +0100
Subject: [PATCH 30/66] Passing 551/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  2 +-
 .../common/reactive/FilterProcessor.java      | 13 +++--
 .../reactive/CancelSubscriber.java            | 13 ++++-
 .../reactive/CumulativeProcessor.java         |  2 +
 .../reactive/FindFirstSubscriber.java         | 20 +++++--
 .../reactive/FlatMapProcessor.java            | 10 ++++
 .../microprofile/reactive/GraphBuilder.java   | 43 ++++++++++-----
 .../RedeemingCompletionSubscriber.java        | 12 +++-
 .../microrofile/reactive/EngineTest.java      | 55 +++++++++++++++++--
 9 files changed, 137 insertions(+), 33 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 236bae06977..17c3ef795b9 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -49,7 +49,7 @@ public BaseProcessor() {
     }
 
     @Override
-    public final void request(long n) {
+    public void request(long n) {
         requested.increment(n, ex -> onError(ex));
         tryRequest(subscription);
         if (done) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index a94ad0e2bc1..4ab733ec058 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -44,10 +44,15 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     protected void hookOnNext(T item) {
-        if (predicate.test(item)) {
-            submit(item);
-        } else {
-            tryRequest(getSubscription());
+        try {
+            if (predicate.test(item)) {
+                submit(item);
+            } else {
+                tryRequest(getSubscription());
+            }
+        } catch (Throwable t) {
+            getSubscription().cancel();
+            onError(t);
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index 03e5d51475e..3484b510917 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -17,18 +17,26 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import io.helidon.common.reactive.Flow;
 
 public class CancelSubscriber implements Flow.Subscriber {
 
+    AtomicBoolean cancelled = new AtomicBoolean(false);
+
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
-        subscription.cancel();
+        if (cancelled.compareAndSet(false, true)) {
+            subscription.cancel();
+        } else {
+            throw new CancellationException();
+        }
     }
 
     @Override
     public void onNext(Object item) {
-        System.out.println();
     }
 
     @Override
@@ -38,6 +46,5 @@ public void onError(Throwable throwable) {
 
     @Override
     public void onComplete() {
-        System.out.println();
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index ed5ed6487c6..d2e1dbbd503 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -41,6 +41,8 @@ public class CumulativeProcessor implements Processor {
     CumulativeProcessor(List> precedingProcessorList) {
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
+        //pass-thru if no processors provided
+        this.processorList.add(HybridProcessor.from(TappedProcessor.create()));
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index 4fd88c69674..6e461d0d796 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -22,11 +22,14 @@
 import java.util.concurrent.CompletionStage;
 
 import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
-public class FindFirstSubscriber implements Flow.Subscriber {
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
+import org.reactivestreams.Subscriber;
+
+public class FindFirstSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage {
     private Flow.Subscription subscription;
     private CompletableFuture completionStage = new CompletableFuture<>();
-    private Optional firstItem = Optional.empty();
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
@@ -51,12 +54,19 @@ public void onError(Throwable throwable) {
     @Override
     @SuppressWarnings("unchecked")
     public void onComplete() {
-        Object optItem = (Object) Optional.empty();
-        completionStage.complete(optItem);
+        if (!completionStage.isDone()) {
+            Object optItem = (Object) Optional.empty();
+            completionStage.complete(optItem);
+        }
     }
 
-
+    @Override
     public CompletionStage getCompletion() {
         return completionStage;
     }
+
+    @Override
+    public Subscriber getSubscriber() {
+        return HybridSubscriber.from(this);
+    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index c77b5760886..a51675838d6 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
 import io.helidon.common.reactive.BaseProcessor;
@@ -35,6 +36,8 @@ public class FlatMapProcessor extends BaseProcessor implements M
 
     private final Function mapper;
 
+    private final AtomicBoolean alreadyRunning = new AtomicBoolean(false);
+
     /**
      * Flatten the elements emitted by publishers produced by the mapper function to this stream.
      *
@@ -58,11 +61,18 @@ protected void hookOnNext(Object item) {
                         this.submit(i);
                     })
                     .run().toCompletableFuture().get();
+            tryRequest(getSubscription());
         } catch (InterruptedException | ExecutionException e) {
             onError(e);
         }
     }
 
+    @Override
+    public void request(long n) {
+        if (alreadyRunning.compareAndSet(false, true)) {
+            super.request(n);
+        }
+    }
 
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index dafe059c5cb..10136dde2d9 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -31,8 +31,10 @@
 import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.MultiMappingProcessor;
 import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
+import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
@@ -46,7 +48,7 @@ public final class GraphBuilder extends HashMap, Consumer
     private Multi multi = null;
     private List> processorList = new ArrayList<>();
     private CompletionStage completionStage = null;
-    private CollectSubscriber subscriberWithCompletionStage = null;
+    private SubscriberWithCompletionStage subscriberWithCompletionStage = null;
 
     @SuppressWarnings("unchecked")
     private GraphBuilder() {
@@ -90,24 +92,26 @@ private GraphBuilder() {
         });
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber();
-            subscribeUpStream();
-            multi.subscribe(cancelSubscriber);
-            this.completionStage = CompletableFuture.completedFuture(null);
+            subscribe(cancelSubscriber);
+            this.subscriberWithCompletionStage =
+                    RedeemingCompletionSubscriber.of(HybridSubscriber.from(cancelSubscriber),
+                            CompletableFuture.completedFuture(null));
         });
         registerStage(Stage.FindFirst.class, stage -> {
             FindFirstSubscriber firstSubscriber = new FindFirstSubscriber<>();
-            subscribeUpStream();
-            multi.subscribe(firstSubscriber);
-            this.completionStage = firstSubscriber.getCompletion();
+            subscribe(firstSubscriber);
+            this.subscriberWithCompletionStage = firstSubscriber;
         });
         registerStage(Stage.SubscriberStage.class, stage -> {
             Subscriber subscriber = (Subscriber) stage.getRsSubscriber();
-            this.completionStage = new CompletableFuture<>();
-            RedeemingCompletionSubscriber completionSubscriber =
-                    RedeemingCompletionSubscriber.of(subscriber, completionStage);
-            // If producer was supplied
-            subscribeUpStream();
-            multi.subscribe(HybridSubscriber.from(completionSubscriber));
+            RedeemingCompletionSubscriber completionSubscriber;
+            if (subscriber instanceof CompletionSubscriber) {
+                completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, ((CompletionSubscriber) subscriber).getCompletion());
+            } else {
+                completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, new CompletableFuture<>());
+            }
+            subscribe(completionSubscriber);
+            this.subscriberWithCompletionStage = completionSubscriber;
         });
         registerStage(Stage.Collect.class, stage -> {
             // Foreach
@@ -211,6 +215,7 @@  Publisher getPublisher() {
     }
 
     @SuppressWarnings("unchecked")
+    @Deprecated
     private void subscribeUpStream() {
         if (multi != null) {
             for (Flow.Processor p : processorList) {
@@ -222,6 +227,18 @@ private void subscribeUpStream() {
         }
     }
 
+    private void subscribe(Subscriber subscriber) {
+        CumulativeProcessor cumulativeProcessor = new CumulativeProcessor(processorList);
+        if (multi != null) {
+            multi.subscribe(HybridProcessor.from(cumulativeProcessor));
+        }
+        cumulativeProcessor.subscribe(subscriber);
+    }
+
+    private void subscribe(Flow.Subscriber subscriber) {
+        subscribe((Subscriber) HybridSubscriber.from(subscriber));
+    }
+
     @SuppressWarnings("unchecked")
     private  GraphBuilder registerStage(Class stageType, Consumer consumer) {
         this.put(stageType, (Consumer) consumer);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index c54fc99b095..2e3ca5e2dec 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -19,6 +19,7 @@
 
 import java.util.concurrent.CompletionStage;
 
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
@@ -30,7 +31,7 @@
  * @param  {@link java.util.concurrent.CompletionStage} payload type
  * @see microprofile-reactive-streams-operators #129
  */
-class RedeemingCompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber {
+class RedeemingCompletionSubscriber implements org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber, SubscriberWithCompletionStage {
 
     private final Subscriber subscriber;
     private final CompletionStage completion;
@@ -57,6 +58,11 @@ public CompletionStage getCompletion() {
         return completion;
     }
 
+    @Override
+    public Subscriber getSubscriber() {
+        return this;
+    }
+
     @Override
     public void onSubscribe(Subscription s) {
         subscriber.onSubscribe(new Subscription() {
@@ -69,7 +75,7 @@ public void request(long n) {
             public void cancel() {
                 s.cancel();
                 //Base processor breaks cancel->onComplete loop, so listen even for downstream call
-                completion.toCompletableFuture().complete(null);
+                //completion.toCompletableFuture().complete(null);
             }
         });
     }
@@ -89,6 +95,6 @@ public void onError(Throwable t) {
     public void onComplete() {
         subscriber.onComplete();
         //Base processor breaks cancel->onComplete loop, so listen even for upstream call
-        completion.toCompletableFuture().complete(null);
+        //completion.toCompletableFuture().complete(null);
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 423e04c533a..0d977e2b16f 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -29,6 +29,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 
@@ -39,6 +40,8 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
@@ -379,7 +382,7 @@ void filter() throws InterruptedException, ExecutionException, TimeoutException
         assertEquals(Arrays.asList(1, 3, 5), cs.toCompletableFuture().get(1, TimeUnit.SECONDS));
     }
 
-    //@Test
+    @Test
     void cancellationException() throws InterruptedException, ExecutionException, TimeoutException {
         assertThrows(CancellationException.class, () -> ReactiveStreams.fromPublisher(subscriber -> subscriber.onSubscribe(new Subscription() {
             @Override
@@ -394,17 +397,61 @@ public void cancel() {
         ).run().toCompletableFuture().get(1, TimeUnit.SECONDS));
     }
 
-    //@Test
+    @Test
     void publisherToSubscriber() throws InterruptedException, ExecutionException, TimeoutException {
         CompletionSubscriber> subscriber = ReactiveStreams.builder()
                 .limit(5L)
                 .findFirst()
                 .build();
-        assertEquals(1, ReactiveStreams.of(1, 2, 3)
+        ReactiveStreams.of(1, 2, 3)
                 .to(subscriber)
                 .run()
                 .toCompletableFuture()
-                .get(1, TimeUnit.SECONDS));
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(1, subscriber.getCompletion().toCompletableFuture().get(1, TimeUnit.SECONDS).get());
+    }
+
+    @Test
+    void filterExceptionCancelUpstream() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.of(1, 2, 3).onTerminate(() -> {
+            cancelled.complete(null);
+        }).filter((foo) -> {
+            throw new TestRuntimeException();
+        }).toList().run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class,
+                () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS),
+                TestRuntimeException.TEST_MSG);
+    }
 
+    @Test
+    void streamOfStreams() throws InterruptedException, ExecutionException, TimeoutException {
+        List result = ReactiveStreams.of(ReactiveStreams.of(1, 2))
+                .flatMap(i -> i)
+                .toList()
+                .run().toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+
+        assertEquals(Arrays.asList(1, 2), result);
+    }
+
+    @Test
+    void reentrantFlatMapPublisher() throws InterruptedException, ExecutionException, TimeoutException {
+        ProcessorBuilder, Integer> flatMap =
+                ReactiveStreams.>builder()
+                        .flatMap(Function.identity());
+        assertEquals(Arrays.asList(1, 2), ReactiveStreams.of(
+                ReactiveStreams.of(1, 2))
+                .via(flatMap)
+                .toList()
+                .run().toCompletableFuture()
+                .get(1, TimeUnit.SECONDS));
+        assertEquals(Arrays.asList(3, 4),
+                ReactiveStreams.of(ReactiveStreams.of(3, 4))
+                        .via(flatMap)
+                        .toList()
+                        .run().toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
     }
 }
\ No newline at end of file

From 01bedd5ffd7d67afa08ff9f2a4a6a5225e3c228e Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 29 Nov 2019 17:26:03 +0100
Subject: [PATCH 31/66] Passing 692/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/DistinctProcessor.java    |  48 +++++++
 .../common/reactive/DropWhileProcessor.java   |  55 ++++++++
 .../io/helidon/common/reactive/Multi.java     |  61 ++++++++-
 .../common/reactive/SkipProcessor.java        |  62 +++++++++
 .../common/reactive/TakeWhileProcessor.java   |  47 +++++++
 .../io/helidon/common/reactive/MultiTest.java |  50 +++++++
 .../reactive/FlatMapProcessor.java            |  13 +-
 .../microprofile/reactive/GraphBuilder.java   |  19 ++-
 .../microprofile/reactive/MapProcessor.java   |  59 +++++++++
 .../microrofile/reactive/EngineTest.java      | 125 +++++++++++++++---
 10 files changed, 508 insertions(+), 31 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
new file mode 100644
index 00000000000..8bcc9eae0bc
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.HashSet;
+
+public class DistinctProcessor extends BaseProcessor implements Multi {
+    private final HashSet distinctSet;
+
+    public DistinctProcessor() {
+        this.distinctSet = new HashSet();
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        try {
+            if (!distinctSet.contains(item)) {
+                distinctSet.add(item);
+                submit(item);
+            } else {
+                tryRequest(getSubscription());
+            }
+        } catch (Throwable t) {
+            getSubscription().cancel();
+            onError(t);
+        }
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
new file mode 100644
index 00000000000..304a0af6c62
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.function.Predicate;
+
+public class DropWhileProcessor extends BaseProcessor implements Multi {
+    private Predicate predicate;
+
+    private boolean foundNotMatching = false;
+
+    /**
+     * Drop the longest prefix of elements from this stream that satisfy the given predicate.
+     *
+     * @param predicate provided predicate to filter stream with
+     */
+    public DropWhileProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        try {
+            if (foundNotMatching || !predicate.test(item)) {
+                foundNotMatching = true;
+                submit(item);
+            } else {
+                tryRequest(getSubscription());
+            }
+        } catch (Throwable t) {
+            getSubscription().cancel();
+            onError(t);
+        }
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 7494ad1d5ab..6268a5d13be 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -27,6 +27,7 @@
 
 /**
  * Multiple items publisher facility.
+ *
  * @param  item type
  */
 public interface Multi extends Subscribable {
@@ -34,7 +35,7 @@ public interface Multi extends Subscribable {
     /**
      * Map this {@link Multi} instance to a new {@link Multi} of another type using the given {@link Mapper}.
      *
-     * @param  mapped item type
+     * @param     mapped item type
      * @param mapper mapper
      * @return Multi
      * @throws NullPointerException if mapper is {@code null}
@@ -57,6 +58,17 @@ default Multi peek(Consumer consumer) {
         return processor;
     }
 
+    /**
+     * Filter out all duplicates.
+     *
+     * @return Multi
+     */
+    default Multi distinct() {
+        DistinctProcessor processor = new DistinctProcessor<>();
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Filter stream items with provided predicate.
      *
@@ -69,6 +81,30 @@ default Multi filter(Predicate predicate) {
         return processor;
     }
 
+    /**
+     * Take the longest prefix of elements from this stream that satisfy the given predicate.
+     *
+     * @param predicate predicate to filter stream with
+     * @return Multi
+     */
+    default Multi takeWhile(Predicate predicate) {
+        TakeWhileProcessor processor = new TakeWhileProcessor<>(predicate);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Drop the longest prefix of elements from this stream that satisfy the given predicate.
+     *
+     * @param predicate predicate to filter stream with
+     * @return Multi
+     */
+    default Multi dropWhile(Predicate predicate) {
+        DropWhileProcessor processor = new DropWhileProcessor<>(predicate);
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Limit stream to allow only specified number of items to pass.
      *
@@ -81,6 +117,18 @@ default Multi limit(long limit) {
         return processor;
     }
 
+    /**
+     * Skip first n items, all the others are emitted.
+     *
+     * @param skip number of items to be skipped
+     * @return Multi
+     */
+    default Multi skip(long skip) {
+        SkipProcessor processor = new SkipProcessor<>(skip);
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Terminal stage, invokes provided consumer for every item in the stream.
      *
@@ -103,7 +151,7 @@ default Single> collectList() {
     /**
      * Collect the items of this {@link Multi} instance into a {@link Single}.
      *
-     * @param  collector container type
+     * @param        collector container type
      * @param collector collector to use
      * @return Single
      * @throws NullPointerException if collector is {@code null}
@@ -116,6 +164,7 @@ default  Single collect(Collector collector) {
 
     /**
      * Get the first item of this {@link Multi} instance as a {@link Single}.
+     *
      * @return Single
      */
     default Single first() {
@@ -127,7 +176,7 @@ default Single first() {
     /**
      * Create a {@link Multi} instance wrapped around the given publisher.
      *
-     * @param  item type
+     * @param     item type
      * @param source source publisher
      * @return Multi
      * @throws NullPointerException if source is {@code null}
@@ -143,7 +192,7 @@ static  Multi from(Publisher source) {
     /**
      * Create a {@link Multi} instance that publishes the given items to a single subscriber.
      *
-     * @param  item type
+     * @param    item type
      * @param items items to publish
      * @return Multi
      * @throws NullPointerException if items is {@code null}
@@ -155,7 +204,7 @@ static  Multi just(Collection items) {
     /**
      * Create a {@link Multi} instance that publishes the given items to a single subscriber.
      *
-     * @param  item type
+     * @param    item type
      * @param items items to publish
      * @return Multi
      * @throws NullPointerException if items is {@code null}
@@ -169,7 +218,7 @@ static  Multi just(T... items) {
      * Create a {@link Multi} instance that reports the given exception to its subscriber(s). The exception is reported by
      * invoking {@link Subscriber#onError(java.lang.Throwable)} when {@link Publisher#subscribe(Subscriber)} is called.
      *
-     * @param  item type
+     * @param    item type
      * @param error exception to hold
      * @return Multi
      * @throws NullPointerException if error is {@code null}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
new file mode 100644
index 00000000000..6108e8ae5bd
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+public class SkipProcessor extends BaseProcessor implements Multi {
+
+    private final AtomicLong counter;
+
+    /**
+     * Processor skips first n items, all the others are emitted.
+     *
+     * @param skip number of items to be skipped
+     */
+    public SkipProcessor(Long skip) {
+        counter = new AtomicLong(skip);
+    }
+
+    @Override
+    protected void tryRequest(Flow.Subscription s) {
+        if (s != null && !getSubscriber().isClosed()) {
+            long n = getRequestedCounter().get();
+            if (n > 0) {
+                //Request one by one with skip
+                s.request(1);
+            }
+        }
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        long actCounter = this.counter.getAndDecrement();
+        if (0 >= actCounter) {
+            submit(item);
+        } else {
+            getRequestedCounter().tryDecrement();
+        }
+        getRequestedCounter().increment(1, this::onError);
+        tryRequest(getSubscription());
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
new file mode 100644
index 00000000000..6096ccedfef
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.function.Predicate;
+
+public class TakeWhileProcessor extends BaseProcessor implements Multi {
+    private Predicate predicate;
+
+    public TakeWhileProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        try {
+            if (predicate.test(item)) {
+                submit(item);
+            } else {
+                tryComplete();
+            }
+        } catch (Throwable t) {
+            getSubscription().cancel();
+            onError(t);
+        }
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index f83f5b467b2..5f15d3880cd 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -20,6 +20,7 @@
 import java.util.Collections;
 import java.util.concurrent.Flow.Subscription;
 
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import io.helidon.common.mapper.Mapper;
@@ -313,6 +314,55 @@ void testLimit() {
         assertThat(streamSum2.get(), is(equalTo(EXPECTED_SUM)));
     }
 
+    @Test
+    void testSkip() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 9);
+        final long TEST_SKIP = 3;
+        final List EXPECTED = Arrays.asList(4, 5, 6, 7, 9);
+
+        List result = Multi.just(TEST_DATA)
+                .skip(TEST_SKIP)
+                .collectList().get();
+
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
+
+    @Test
+    void testTakeWhile() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList(1, 2, 3, 4, 3, 2, 1, 0);
+        final List EXPECTED = Arrays.asList(1, 2, 3);
+
+        List result = Multi.just(TEST_DATA)
+                .takeWhile(i -> i < 4)
+                .collectList().get();
+
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
+
+    @Test
+    void testDropWhile() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList(1, 2, 3, 4, 3, 2, 1, 0);
+        final List EXPECTED = Arrays.asList(4, 3, 2, 1, 0);
+
+        List result = Multi.just(TEST_DATA)
+                .dropWhile(i -> i < 4)
+                .collectList().get();
+
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
+
+    @Test
+    void distinct() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList(1, 2, 1, 2, 3, 2, 1, 3);
+        final List EXPECTED = Arrays.asList(1, 2, 3);
+
+        List result = Multi.just(TEST_DATA)
+                .distinct()
+                .collectList().get();
+
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
+
     private static class MultiTestSubscriber extends TestSubscriber {
 
         @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index a51675838d6..b6025d1a94f 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
@@ -50,19 +51,21 @@ public FlatMapProcessor(Function mapper) {
 
     @Override
     protected void hookOnNext(Object item) {
-        Graph graph = mapper.apply(item);
-        HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
-        Publisher publisher = streamEngine.buildPublisher(graph);
         try {
+            Graph graph = mapper.apply(item);
+            HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
+            Publisher publisher = streamEngine.buildPublisher(graph);
             ReactiveStreams
                     .fromPublisher(publisher)
                     .forEach(i -> {
                         this.getRequestedCounter().increment(1L, this::onError);
                         this.submit(i);
                     })
-                    .run().toCompletableFuture().get();
+                    //TODO: Timeout is bad solution!
+                    .run().toCompletableFuture().get(10, TimeUnit.SECONDS);
             tryRequest(getSubscription());
-        } catch (InterruptedException | ExecutionException e) {
+        } catch (Throwable e) {
+            super.getSubscription().cancel();
             onError(e);
         }
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 10136dde2d9..ed0fb19aea0 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -25,12 +25,15 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import io.helidon.common.reactive.DistinctProcessor;
+import io.helidon.common.reactive.DropWhileProcessor;
 import io.helidon.common.reactive.FilterProcessor;
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.LimitProcessor;
 import io.helidon.common.reactive.Multi;
-import io.helidon.common.reactive.MultiMappingProcessor;
 import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.common.reactive.SkipProcessor;
+import io.helidon.common.reactive.TakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
@@ -69,11 +72,17 @@ private GraphBuilder() {
         });
         registerStage(Stage.Map.class, stage -> {
             Function mapper = (Function) stage.getMapper();
-            processorList.add(new MultiMappingProcessor<>(mapper::apply));
+            processorList.add(new MapProcessor<>(mapper::apply));
         });
         registerStage(Stage.Filter.class, stage -> {
             processorList.add(new FilterProcessor(stage.getPredicate()));
         });
+        registerStage(Stage.TakeWhile.class, stage -> {
+            processorList.add(new TakeWhileProcessor(stage.getPredicate()));
+        });
+        registerStage(Stage.DropWhile.class, stage -> {
+            processorList.add(new DropWhileProcessor(stage.getPredicate()));
+        });
         registerStage(Stage.Peek.class, stage -> {
             Consumer peekConsumer = (Consumer) stage.getConsumer();
             processorList.add(new PeekProcessor<>(peekConsumer));
@@ -81,6 +90,12 @@ private GraphBuilder() {
         registerStage(Stage.Limit.class, stage -> {
             processorList.add(new LimitProcessor(stage.getLimit()));
         });
+        registerStage(Stage.Skip.class, stage -> {
+            processorList.add(new SkipProcessor(stage.getSkip()));
+        });
+        registerStage(Stage.Distinct.class, stage -> {
+            processorList.add(new DistinctProcessor<>());
+        });
         registerStage(Stage.FlatMap.class, stage -> {
             processorList.add(new FlatMapProcessor(stage.getMapper()));
         });
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
new file mode 100644
index 00000000000..7e394451646
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Objects;
+
+import io.helidon.common.mapper.Mapper;
+import io.helidon.common.reactive.BaseProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
+
+/**
+ * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
+ *
+ * @param  subscribed type
+ * @param  published type
+ */
+public final class MapProcessor extends BaseProcessor implements Multi {
+
+    private final Mapper mapper;
+
+    /**
+     * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
+     *
+     * @param mapper supplied for all items to be mapped with
+     */
+    public MapProcessor(Mapper mapper) {
+        this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
+    @Override
+    protected void hookOnNext(T item) {
+        U value = mapper.map(item);
+        if (value == null) {
+            getSubscription().cancel();
+            onError(new NullPointerException("Mapper returned a null value"));
+        } else {
+            submit(value);
+        }
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 0d977e2b16f..dd02c40f093 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -337,24 +337,6 @@ void publisherWithTerminate() throws InterruptedException, ExecutionException, T
         terminator.get(1, TimeUnit.SECONDS);
     }
 
-    @Test
-    void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
-        CompletableFuture outerCancelled = new CompletableFuture<>();
-        CompletableFuture innerCancelled = new CompletableFuture<>();
-        ReactiveStreams.of("1", "2", "3", "1", "2", "3")
-                .onTerminate(() -> outerCancelled.complete(null))
-                .flatMap((i) -> ReactiveStreams.of("1", "2", "3", "1", "2", "3")
-                        .onTerminate(() -> innerCancelled.complete(null))
-                )
-                .limit(5L)
-                .toList()
-                .run()
-                .toCompletableFuture()
-                .get(2, TimeUnit.SECONDS);
-        innerCancelled.get(1, TimeUnit.SECONDS);
-        outerCancelled.get(1, TimeUnit.SECONDS);
-    }
-
     @Test
     void concatCancel() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture cancelled = new CompletableFuture<>();
@@ -454,4 +436,111 @@ void reentrantFlatMapPublisher() throws InterruptedException, ExecutionException
                         .run().toCompletableFuture()
                         .get(1, TimeUnit.SECONDS));
     }
+
+    @Test
+    void concatCancelOtherStage() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+
+        CompletionStage completion = ReactiveStreams.concat(
+                ReactiveStreams.failed(new TestRuntimeException()),
+                ReactiveStreams.of(1, 2.3).onTerminate(() -> cancelled.complete(null)))
+                .ignore()
+                .run();
+
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> completion.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
+    @Test
+    void flatMapExceptionPropagation() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.of(1, 2, 3)
+                .onTerminate(() -> cancelled.complete(null))
+                .flatMap(foo -> {
+                    throw new TestRuntimeException();
+                })
+                .toList()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
+    @Test
+    void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture outerCancelled = new CompletableFuture<>();
+        CompletableFuture innerCancelled = new CompletableFuture<>();
+        ReactiveStreams.of("1", "2", "3", "1", "2", "3")
+                .onTerminate(() -> outerCancelled.complete(null))
+                .flatMap((i) -> ReactiveStreams.of("1", "2", "3", "1", "2", "3")
+                        .onTerminate(() -> innerCancelled.complete(null))
+                )
+                .limit(5L)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(2, TimeUnit.SECONDS);
+        innerCancelled.get(1, TimeUnit.SECONDS);
+        outerCancelled.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void flatMapSubStreamException() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.of(1, 2, 3)
+                .onTerminate(() -> cancelled.complete(null))
+                .flatMap(f -> ReactiveStreams.failed(new TestRuntimeException()))
+                .toList()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class,
+                () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS),
+                TestRuntimeException.TEST_MSG);
+    }
+
+    @Test
+    void dropWhile() throws InterruptedException, ExecutionException, TimeoutException {
+        ProcessorBuilder dropWhile = ReactiveStreams.builder()
+                .dropWhile(i -> i < 3);
+
+        List firstResult = ReactiveStreams.of(1, 2, 3, 4)
+                .via(dropWhile)
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        List secondResult = ReactiveStreams.of(0, 1, 6, 7)
+                .via(dropWhile)
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        assertEquals(Arrays.asList(3, 4), firstResult);
+        assertEquals(Arrays.asList(6, 7), secondResult);
+    }
+
+    @Test
+    void disctinct() throws InterruptedException, ExecutionException, TimeoutException {
+        ProcessorBuilder distinct = ReactiveStreams.builder().distinct();
+        List firstResult = ReactiveStreams.of(1, 2, 2, 3)
+                .via(distinct)
+                .toList()
+                .run().toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        List secondResult = ReactiveStreams.of(3, 3, 4, 5)
+                .via(distinct)
+                .toList()
+                .run().toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(1, 2, 3), firstResult);
+        assertEquals(Arrays.asList(3, 4, 5), secondResult);
+    }
+
+    @Test
+    void nullInMap() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.of(1, 2, 3)
+                .onTerminate(() -> cancelled.complete(null))
+                .map(t -> null)
+                .toList().run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
 }
\ No newline at end of file

From 58e02ad8b50e4d9e420ed2d3dc8bec1fa4692266 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 30 Nov 2019 11:47:30 +0100
Subject: [PATCH 32/66] Passing 713/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/FlatMapProcessor.java            |  4 +-
 .../FromCompletionStagePublisher.java         | 74 +++++++++++++++++++
 .../microprofile/reactive/GraphBuilder.java   |  6 ++
 .../microrofile/reactive/EngineTest.java      | 24 ++++++
 4 files changed, 106 insertions(+), 2 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index b6025d1a94f..3e0e995476d 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -61,8 +61,8 @@ protected void hookOnNext(Object item) {
                         this.getRequestedCounter().increment(1L, this::onError);
                         this.submit(i);
                     })
-                    //TODO: Timeout is bad solution!
-                    .run().toCompletableFuture().get(10, TimeUnit.SECONDS);
+                    //TODO: Timeout is bad solution! whenComplete should do the trick??
+                    .run().toCompletableFuture().get(2, TimeUnit.SECONDS);
             tryRequest(getSubscription());
         } catch (Throwable e) {
             super.getSubscription().cancel();
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
new file mode 100644
index 00000000000..5f0fde0dc02
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class FromCompletionStagePublisher implements Publisher {
+
+    private CompletionStage completionStage;
+    private boolean nullable;
+    private Subscriber subscriber;
+
+    public FromCompletionStagePublisher(CompletionStage completionStage, boolean nullable) {
+        this.nullable = nullable;
+        Objects.requireNonNull(completionStage);
+        this.completionStage = completionStage;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void subscribe(Subscriber subscriber) {
+        this.subscriber = subscriber;
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+
+            }
+        });
+        completionStage.whenComplete((item, throwable) -> {
+            if (Objects.isNull(throwable)) {
+                emit((T) item);
+            } else {
+                subscriber.onError(throwable);
+            }
+        });
+    }
+
+    private void emit(T item) {
+        if (!Objects.isNull(item)) {
+            subscriber.onNext(item);
+            subscriber.onComplete();
+        } else {
+            if (nullable) {
+                subscriber.onComplete();
+            } else {
+                subscriber.onError(new NullPointerException("Null in non nullable completion stage."));
+            }
+        }
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index ed0fb19aea0..8172aa70922 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -70,6 +70,12 @@ private GraphBuilder() {
         registerStage(Stage.Failed.class, stage -> {
             multi = Multi.from(new FailedPublisher(stage.getError()));
         });
+        registerStage(Stage.FromCompletionStage.class, stage -> {
+            multi = MultiRS.toMulti(new FromCompletionStagePublisher(stage.getCompletionStage(), false));
+        });
+        registerStage(Stage.FromCompletionStageNullable.class, stage -> {
+            multi = MultiRS.toMulti(new FromCompletionStagePublisher(stage.getCompletionStage(), true));
+        });
         registerStage(Stage.Map.class, stage -> {
             Function mapper = (Function) stage.getMapper();
             processorList.add(new MapProcessor<>(mapper::apply));
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index dd02c40f093..61b7118d96e 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -19,6 +19,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.StringJoiner;
@@ -543,4 +544,27 @@ void nullInMap() throws InterruptedException, ExecutionException, TimeoutExcepti
         cancelled.get(1, TimeUnit.SECONDS);
         assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS));
     }
+
+    @Test
+    void fromCompletionStage() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Collections.singletonList("TEST"),
+                ReactiveStreams.fromCompletionStage(CompletableFuture.completedFuture("TEST"))
+                        .toList()
+                        .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void fromCompletionStageWithNullNegative() throws InterruptedException, ExecutionException, TimeoutException {
+        assertThrows(ExecutionException.class, () -> ReactiveStreams.fromCompletionStage(CompletableFuture.completedFuture(null))
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void fromCompletionStageWithNullPositive() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Optional.empty(),
+                ReactiveStreams.fromCompletionStageNullable(CompletableFuture.completedFuture(null))
+                        .findFirst()
+                        .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
 }
\ No newline at end of file

From 41b535d685909cfc2b75026121c92af530220e7d Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sun, 1 Dec 2019 22:24:53 +0100
Subject: [PATCH 33/66] Passing 838/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |   2 +-
 .../reactive/ConcatPublisher.java             |  98 ++++++++++-------
 .../reactive/FailedPublisher.java             |   2 +-
 .../reactive/FlatMapProcessor.java            |  13 ++-
 .../microprofile/reactive/GraphBuilder.java   |  19 ++++
 .../reactive/OnErrorResumeProcessor.java      |  45 ++++++++
 .../reactive/hybrid/CoupledProcessor.java     | 101 ++++++++++++++++++
 .../microrofile/reactive/EngineTest.java      | 101 ++++++++++++++----
 8 files changed, 316 insertions(+), 65 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 17c3ef795b9..8db64f00ced 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -88,7 +88,7 @@ public final void onNext(T item) {
     }
 
     @Override
-    public final void onError(Throwable ex) {
+    public void onError(Throwable ex) {
         done = true;
         if (error == null) {
             error = ex;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
index 671a8fd3734..3954a594f26 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
@@ -17,7 +17,7 @@
 
 package io.helidon.microprofile.reactive;
 
-import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
 
 import org.reactivestreams.Processor;
@@ -26,96 +26,114 @@
 import org.reactivestreams.Subscription;
 
 public class ConcatPublisher implements Publisher {
+    private FirstProcessor firstProcessor;
+    private SecondProcessor secondProcessor;
     private Subscriber subscriber;
     private Publisher firstPublisher;
     private Publisher secondPublisher;
-    private TransparentProcessor firstTransparentProcessor;
+    private AtomicLong requested = new AtomicLong();
+
 
     public ConcatPublisher(Publisher firstPublisher, Publisher secondPublisher) {
         this.firstPublisher = firstPublisher;
         this.secondPublisher = secondPublisher;
-
     }
 
     @Override
     public void subscribe(Subscriber subscriber) {
         this.subscriber = (Subscriber) subscriber;
-        firstTransparentProcessor = new TransparentProcessor(firstPublisher, secondPublisher);
+
+        this.firstProcessor = new FirstProcessor();
+        this.secondProcessor = new SecondProcessor();
+
+        firstPublisher.subscribe(firstProcessor);
 
         subscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
-                firstTransparentProcessor.request(n);
-
+                requested.set(n);
+                if (!firstProcessor.complete) {
+                    firstProcessor.subscription.request(n);
+                } else {
+                    secondProcessor.subscription.request(n);
+                }
             }
 
             @Override
             public void cancel() {
-                firstTransparentProcessor.cancel();
+                firstProcessor.subscription.cancel();
+                secondProcessor.subscription.cancel();
             }
         });
     }
 
-    private class TransparentProcessor implements Processor {
+    private class FirstProcessor implements Processor {
 
         private Subscription subscription;
-        private boolean isCompleted = false;
-        private AtomicLong requests = new AtomicLong();
-        private TransparentProcessor secondTransparentProcessor;
+        private boolean complete = false;
 
-        private TransparentProcessor() {
+        @Override
+        public void subscribe(Subscriber s) {
         }
 
-        private TransparentProcessor(Publisher firstPublisher, Publisher secondPublisher) {
-            firstPublisher.subscribe(this);
-            secondTransparentProcessor = new TransparentProcessor();
-            secondPublisher.subscribe(secondTransparentProcessor);
+        @Override
+        public void onSubscribe(Subscription subscription) {
+            this.subscription = subscription;
+            secondPublisher.subscribe(secondProcessor);
         }
 
         @Override
-        public void subscribe(Subscriber subscriber) {
+        @SuppressWarnings("unchecked")
+        public void onNext(Object o) {
+            requested.decrementAndGet();
+            ConcatPublisher.this.subscriber.onNext((T) o);
         }
 
         @Override
-        public void onSubscribe(Subscription subscription) {
-            this.subscription = subscription;
+        public void onError(Throwable t) {
+            complete = true;
+            Optional.ofNullable(secondProcessor.subscription).ifPresent(Subscription::cancel);
+            subscription.cancel();
+            ConcatPublisher.this.subscriber.onError(t);
         }
 
-        private void request(long n) {
-            requests.set(n);
-            if (!isCompleted) {
-                this.subscription.request(n);
-            } else {
-                secondTransparentProcessor.subscription.request(n);
-            }
+        @Override
+        public void onComplete() {
+            complete = true;
+            Optional.ofNullable(secondProcessor.subscription).ifPresent(s -> s.request(requested.get()));
+        }
+    }
+
+
+    private class SecondProcessor implements Processor {
+
+        private Subscription subscription;
+
+        @Override
+        public void subscribe(Subscriber s) {
         }
 
-        private void cancel() {
-            this.subscription.cancel();
-            this.secondTransparentProcessor.subscription.cancel();
+        @Override
+        public void onSubscribe(Subscription subscription) {
+            this.subscription = subscription;
         }
 
         @Override
         @SuppressWarnings("unchecked")
-        public void onNext(Object t) {
-            requests.decrementAndGet();
-            ConcatPublisher.this.subscriber.onNext((T) t);
+        public void onNext(Object o) {
+            ConcatPublisher.this.subscriber.onNext((T) o);
         }
 
         @Override
         public void onError(Throwable t) {
-                this.isCompleted = true;
-                ConcatPublisher.this.subscriber.onError(t);
+            firstProcessor.subscription.cancel();
+            subscription.cancel();
+            ConcatPublisher.this.subscriber.onError(t);
         }
 
         @Override
         public void onComplete() {
-            if (!Objects.isNull(secondTransparentProcessor)) {
-                this.isCompleted = true;
-                this.secondTransparentProcessor.subscription.request(requests.get());
-            } else {
-                ConcatPublisher.this.subscriber.onComplete();
-            }
+            ConcatPublisher.this.subscriber.onComplete();
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
index e06a12414d5..2c0ce6869c2 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
@@ -29,7 +29,6 @@ public FailedPublisher(Throwable throwable) {
 
     @Override
     public void subscribe(Flow.Subscriber subscriber) {
-        subscriber.onError(throwable);
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
@@ -41,5 +40,6 @@ public void cancel() {
 
             }
         });
+        subscriber.onError(throwable);
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 3e0e995476d..bbb5f57b70d 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -17,8 +17,6 @@
 
 package io.helidon.microprofile.reactive;
 
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
@@ -61,9 +59,14 @@ protected void hookOnNext(Object item) {
                         this.getRequestedCounter().increment(1L, this::onError);
                         this.submit(i);
                     })
-                    //TODO: Timeout is bad solution! whenComplete should do the trick??
-                    .run().toCompletableFuture().get(2, TimeUnit.SECONDS);
-            tryRequest(getSubscription());
+                    .run().whenComplete((aVoid, throwable) -> {
+                if (throwable != null) {
+                    super.getSubscription().cancel();
+                    onError(throwable);
+                } else {
+                    tryRequest(getSubscription());
+                }
+            });
         } catch (Throwable e) {
             super.getSubscription().cancel();
             onError(e);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 8172aa70922..ac7907bdbb4 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -34,6 +34,7 @@
 import io.helidon.common.reactive.PeekProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
+import io.helidon.microprofile.reactive.hybrid.CoupledProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
@@ -93,6 +94,9 @@ private GraphBuilder() {
             Consumer peekConsumer = (Consumer) stage.getConsumer();
             processorList.add(new PeekProcessor<>(peekConsumer));
         });
+        registerStage(Stage.ProcessorStage.class, stage -> {
+            processorList.add(HybridProcessor.from((Processor) stage.getRsProcessor()));
+        });
         registerStage(Stage.Limit.class, stage -> {
             processorList.add(new LimitProcessor(stage.getLimit()));
         });
@@ -105,12 +109,27 @@ private GraphBuilder() {
         registerStage(Stage.FlatMap.class, stage -> {
             processorList.add(new FlatMapProcessor(stage.getMapper()));
         });
+        registerStage(Stage.Coupled.class, stage -> {
+            Subscriber subscriber = GraphBuilder.create()
+                    .from(stage.getSubscriber()).getSubscriberWithCompletionStage().getSubscriber();
+            Publisher publisher = GraphBuilder.create().from(stage.getPublisher()).getPublisher();
+            processorList.add(HybridProcessor.from(new CoupledProcessor<>(subscriber, publisher)));
+        });
         registerStage(Stage.OnTerminate.class, stage -> {
             processorList.add(TappedProcessor.create()
                     .onComplete(stage.getAction())
                     .onCancel((s) -> stage.getAction().run())
                     .onError((t) -> stage.getAction().run()));
         });
+        registerStage(Stage.OnComplete.class, stage -> {
+            processorList.add(TappedProcessor.create().onComplete(stage.getAction()));
+        });
+        registerStage(Stage.OnError.class, stage -> {
+            processorList.add(TappedProcessor.create().onError(stage.getConsumer()));
+        });
+        registerStage(Stage.OnErrorResume.class, stage -> {
+            processorList.add(new OnErrorResumeProcessor(stage.getFunction()));
+        });
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber();
             subscribe(cancelSubscriber);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
new file mode 100644
index 00000000000..2ad208601a7
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.function.Function;
+
+import io.helidon.common.reactive.BaseProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
+
+public class OnErrorResumeProcessor extends BaseProcessor implements Multi {
+
+
+    private Function supplier;
+
+    public OnErrorResumeProcessor(Function supplier) {
+        this.supplier = supplier;
+    }
+
+    @Override
+    public void onError(Throwable ex) {
+        submit(supplier.apply(ex));
+        tryComplete();
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java
new file mode 100644
index 00000000000..d4d8d2b450b
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive.hybrid;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class CoupledProcessor implements Processor {
+
+    private Subscriber subscriber;
+    private Publisher publisher;
+    private Subscriber downStreamSubscriber;
+    private Subscription upStreamSubscription;
+    private Subscription downStreamsSubscription;
+
+
+    public CoupledProcessor(Subscriber subscriber, Publisher publisher) {
+        this.subscriber = subscriber;
+        this.publisher = publisher;
+    }
+
+    @Override
+    public void subscribe(Subscriber downStreamSubscriber) {
+
+        this.downStreamSubscriber = downStreamSubscriber;
+        publisher.subscribe(new Subscriber() {
+
+            @Override
+            public void onSubscribe(Subscription downStreamsSubscription) {
+                CoupledProcessor.this.downStreamsSubscription = downStreamsSubscription;
+            }
+
+            @Override
+            @SuppressWarnings("unchecked")
+            public void onNext(T t) {
+                downStreamSubscriber.onNext((R) t);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                downStreamSubscriber.onError(t);
+            }
+
+            @Override
+            public void onComplete() {
+                downStreamSubscriber.onComplete();
+            }
+        });
+
+        downStreamSubscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                downStreamsSubscription.request(n);
+            }
+
+            @Override
+            public void cancel() {
+                downStreamsSubscription.cancel();
+            }
+        });
+    }
+
+    @Override
+    public void onSubscribe(Subscription upStreamSubscription) {
+        this.upStreamSubscription = upStreamSubscription;
+        subscriber.onSubscribe(upStreamSubscription);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onNext(T t) {
+        subscriber.onNext(t);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 61b7118d96e..e06c680c87a 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -201,6 +201,24 @@ void concat() throws InterruptedException, ExecutionException, TimeoutException
         assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), resultList);
     }
 
+    @Test
+    void concatCancelOnFail() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+
+        CompletionStage completion =
+                ReactiveStreams
+                        .concat(
+                                ReactiveStreams.failed(new TestRuntimeException()),
+                                ReactiveStreams.generate(() -> 1)
+                                        .onTerminate(() -> cancelled.complete(null))
+                        )
+                        .ignore()
+                        .run();
+
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> completion.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
     @Test
     void complStage() throws InterruptedException, ExecutionException, TimeoutException {
         final List resultList = new ArrayList<>();
@@ -466,24 +484,6 @@ void flatMapExceptionPropagation() throws InterruptedException, ExecutionExcepti
         assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
     }
 
-    @Test
-    void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
-        CompletableFuture outerCancelled = new CompletableFuture<>();
-        CompletableFuture innerCancelled = new CompletableFuture<>();
-        ReactiveStreams.of("1", "2", "3", "1", "2", "3")
-                .onTerminate(() -> outerCancelled.complete(null))
-                .flatMap((i) -> ReactiveStreams.of("1", "2", "3", "1", "2", "3")
-                        .onTerminate(() -> innerCancelled.complete(null))
-                )
-                .limit(5L)
-                .toList()
-                .run()
-                .toCompletableFuture()
-                .get(2, TimeUnit.SECONDS);
-        innerCancelled.get(1, TimeUnit.SECONDS);
-        outerCancelled.get(1, TimeUnit.SECONDS);
-    }
-
     @Test
     void flatMapSubStreamException() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture cancelled = new CompletableFuture<>();
@@ -567,4 +567,69 @@ void fromCompletionStageWithNullPositive() throws InterruptedException, Executio
                         .findFirst()
                         .run().toCompletableFuture().get(1, TimeUnit.SECONDS));
     }
+
+    @Test
+    void coupled() throws InterruptedException, ExecutionException, TimeoutException {
+
+        CompletionSubscriber> subscriber = ReactiveStreams.builder().toList().build();
+        Publisher publisher = ReactiveStreams.of("4", "5", "6").buildRs();
+
+        Processor processor = ReactiveStreams.coupled(subscriber, publisher).buildRs();
+//        Processor processor = ReactiveStreams.builder().map(String::valueOf).buildRs();
+
+        List result = ReactiveStreams.of(1, 2, 3)
+                .via(processor)
+                .peek(s -> {
+                    System.out.println(">>>>" + s);
+                })
+                .toList()
+                .run()
+                .toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        subscriber.getCompletion().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        assertEquals(Arrays.asList("4", "5", "6"), result);
+    }
+
+    @Test
+    void generate() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Arrays.asList(4, 4, 4),
+                ReactiveStreams.generate(() -> 4)
+                        .limit(3L)
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void onErrorResume() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Collections.singletonList(4),
+                ReactiveStreams
+                        .generate(() -> 1)
+                        .limit(3L)
+                        .peek(i -> {
+                            throw new TestRuntimeException();
+                        })
+                        .onErrorResume(throwable -> 4)
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture outerCancelled = new CompletableFuture<>();
+        CompletableFuture innerCancelled = new CompletableFuture<>();
+        ReactiveStreams.generate(() -> 4)
+                .onTerminate(() -> outerCancelled.complete(null))
+                .flatMap(i -> ReactiveStreams.generate(() -> 5)
+                        .onTerminate(() -> innerCancelled.complete(null)))
+                .limit(5)
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        outerCancelled.get(1, TimeUnit.SECONDS);
+        innerCancelled.get(1, TimeUnit.SECONDS);
+    }
 }
\ No newline at end of file

From 589df80820a4e280a573f75f42f90c6fc8fc51e1 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 2 Dec 2019 19:10:08 +0100
Subject: [PATCH 34/66] Passing 886/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/FlatMapProcessor.java            | 170 +++++++++++++-----
 .../microprofile/reactive/GraphBuilder.java   |  17 +-
 .../microrofile/reactive/EngineTest.java      |  29 ++-
 3 files changed, 168 insertions(+), 48 deletions(-)

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index bbb5f57b70d..e5db7d03375 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -17,76 +17,160 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.BaseProcessor;
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.Multi;
-
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
+import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 
 /**
  * Flatten the elements emitted by publishers produced by the mapper function to this stream.
  */
-public class FlatMapProcessor extends BaseProcessor implements Multi {
+public class FlatMapProcessor implements Processor {
+
+    private Function mapper;
+
+    private final AtomicBoolean innerPublisherCompleted = new AtomicBoolean(true);
+    private Subscriber subscriber;
+    private Subscription subscription;
+    private final AtomicLong requestCounter = new AtomicLong();
+    private Subscription innerSubscription;
 
-    private final Function mapper;
 
-    private final AtomicBoolean alreadyRunning = new AtomicBoolean(false);
+    private FlatMapProcessor() {
+    }
+
+    @SuppressWarnings("unchecked")
+    static FlatMapProcessor fromIterableMapper(Function> mapper) {
+        Function> iterableMapper = (Function>) mapper;
+        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
+        flatMapProcessor.mapper = o -> ReactiveStreams.fromIterable(iterableMapper.apply(o)).buildRs();
+        return flatMapProcessor;
+    }
 
-    /**
-     * Flatten the elements emitted by publishers produced by the mapper function to this stream.
-     *
-     * @param mapper publisher to flatten his data to this stream
-     */
     @SuppressWarnings("unchecked")
-    public FlatMapProcessor(Function mapper) {
-        this.mapper = (Function) mapper;
+    static FlatMapProcessor fromPublisherMapper(Function mapper) {
+        Function publisherMapper = (Function) mapper;
+        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
+        flatMapProcessor.mapper = o -> new HelidonReactiveStreamEngine().buildPublisher(publisherMapper.apply(o));
+        return flatMapProcessor;
+    }
+
+    @SuppressWarnings("unchecked")
+    static FlatMapProcessor fromCompletionStage(Function> mapper) {
+        Function> csMapper = (Function>) mapper;
+        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
+        flatMapProcessor.mapper = o -> (Publisher) s -> s.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                csMapper.apply(o).whenComplete((payload, throwable) -> {
+                    if (Objects.nonNull(throwable)) {
+                        s.onError(throwable);
+                    } else {
+                        s.onNext(payload);
+                    }
+                });
+            }
+
+            @Override
+            public void cancel() {
+
+            }
+        });
+        return flatMapProcessor;
+    }
+
+    private class FlatMapSubscription implements Subscription {
+        @Override
+        public void request(long n) {
+            requestCounter.addAndGet(n);
+            if (innerPublisherCompleted.getAndSet(false)) {
+                subscription.request(requestCounter.get());
+            }
+        }
+
+        @Override
+        public void cancel() {
+            subscription.cancel();
+            innerSubscription.cancel();
+        }
     }
 
     @Override
-    protected void hookOnNext(Object item) {
-        try {
-            Graph graph = mapper.apply(item);
-            HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
-            Publisher publisher = streamEngine.buildPublisher(graph);
-            ReactiveStreams
-                    .fromPublisher(publisher)
-                    .forEach(i -> {
-                        this.getRequestedCounter().increment(1L, this::onError);
-                        this.submit(i);
-                    })
-                    .run().whenComplete((aVoid, throwable) -> {
-                if (throwable != null) {
-                    super.getSubscription().cancel();
-                    onError(throwable);
-                } else {
-                    tryRequest(getSubscription());
-                }
-            });
-        } catch (Throwable e) {
-            super.getSubscription().cancel();
-            onError(e);
+    public void subscribe(Subscriber subscriber) {
+        this.subscriber = subscriber;
+        if (Objects.nonNull(this.subscription)) {
+            subscriber.onSubscribe(new FlatMapSubscription());
         }
     }
 
     @Override
-    public void request(long n) {
-        if (alreadyRunning.compareAndSet(false, true)) {
-            super.request(n);
+    public void onSubscribe(Subscription subscription) {
+        this.subscription = subscription;
+        if (Objects.nonNull(subscriber)) {
+            subscriber.onSubscribe(new FlatMapSubscription());
         }
     }
 
     @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
+    public void onNext(Object o) {
+        onNextInner(o);
     }
 
     @Override
-    public String toString() {
-        return String.format("FlatMapProcessor{mapper=%s}", mapper);
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+        innerSubscription.cancel();
+    }
+
+    @SuppressWarnings("unchecked")
+    private void onNextInner(Object item) {
+        try {
+            Publisher publisher = mapper.apply(item);
+            publisher.subscribe(new InnerSubscriber());
+        } catch (Throwable e) {
+            this.subscription.cancel();
+            this.onError(e);
+        }
+    }
+
+    private class InnerSubscriber implements Subscriber {
+
+        @Override
+        public void onSubscribe(Subscription innerSubscription) {
+            FlatMapProcessor.this.innerSubscription = innerSubscription;
+            innerSubscription.request(1L);
+        }
+
+        @Override
+        public void onNext(Object o) {
+            FlatMapProcessor.this.subscriber.onNext(o);
+            requestCounter.decrementAndGet();
+            innerSubscription.request(1L);
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            FlatMapProcessor.this.subscription.cancel();
+            FlatMapProcessor.this.onError(t);
+        }
+
+        @Override
+        public void onComplete() {
+            innerPublisherCompleted.set(true);
+            subscription.request(requestCounter.get());
+        }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index ac7907bdbb4..1271124b722 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -107,7 +107,22 @@ private GraphBuilder() {
             processorList.add(new DistinctProcessor<>());
         });
         registerStage(Stage.FlatMap.class, stage -> {
-            processorList.add(new FlatMapProcessor(stage.getMapper()));
+            processorList.add(
+                    HybridProcessor.from(
+                            FlatMapProcessor.fromPublisherMapper(
+                                    stage.getMapper())));
+        });
+        registerStage(Stage.FlatMapIterable.class, stage -> {
+            processorList.add(
+                    HybridProcessor.from(
+                            FlatMapProcessor.fromIterableMapper(
+                                    stage.getMapper())));
+        });
+        registerStage(Stage.FlatMapCompletionStage.class, stage -> {
+            processorList.add(
+                    HybridProcessor.from(
+                            FlatMapProcessor.fromCompletionStage(
+                                    stage.getMapper())));
         });
         registerStage(Stage.Coupled.class, stage -> {
             Subscriber subscriber = GraphBuilder.create()
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index e06c680c87a..cd9e89c596c 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -148,7 +148,7 @@ void subscriberCreation() throws ExecutionException, InterruptedException, Timeo
 
     @Test
     void processorBuilder() {
-        StringBuffer stringBuffer = new StringBuffer();
+        StringBuilder stringBuffer = new StringBuilder();
 
         Publisher publisherBuilder =
                 ReactiveStreams
@@ -620,6 +620,16 @@ void onErrorResume() throws InterruptedException, ExecutionException, TimeoutExc
 
     @Test
     void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
+        try {
+            ReactiveStreams.of(1, 2, 3)
+                    // .onTerminate(() -> cancelled.complete(null))
+                    //  .flatMap(f -> ReactiveStreams.failed(new TestRuntimeException()))
+                    .toList()
+                    .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        } catch (ExecutionException ignored) {
+
+        }
+
         CompletableFuture outerCancelled = new CompletableFuture<>();
         CompletableFuture innerCancelled = new CompletableFuture<>();
         ReactiveStreams.generate(() -> 4)
@@ -628,8 +638,19 @@ void flatMapCancelPropagation() throws InterruptedException, ExecutionException,
                         .onTerminate(() -> innerCancelled.complete(null)))
                 .limit(5)
                 .toList()
-                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
-        outerCancelled.get(1, TimeUnit.SECONDS);
-        innerCancelled.get(1, TimeUnit.SECONDS);
+                .run().toCompletableFuture().get(200, TimeUnit.MILLISECONDS);
+        outerCancelled.get(200, TimeUnit.MILLISECONDS);
+        innerCancelled.get(200, TimeUnit.MILLISECONDS);
+    }
+
+    @Test
+    void flatMap() throws InterruptedException, ExecutionException, TimeoutException {
+        List result = ReactiveStreams.generate(() -> 4)
+                .flatMap(i -> ReactiveStreams.of(9, 8, 7))
+                .limit(4)
+                .toList()
+                .run().toCompletableFuture().get(200, TimeUnit.MILLISECONDS);
+
+        assertEquals(Arrays.asList(9, 8, 7, 9), result);
     }
 }
\ No newline at end of file

From f37420e74604072c9b89eee2b45488ca9095be61 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 3 Dec 2019 14:29:24 +0100
Subject: [PATCH 35/66] Passing 946/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/CancelSubscriber.java            |   2 +-
 .../{hybrid => }/CoupledProcessor.java        |  21 +++-
 .../reactive/FlatMapProcessor.java            |  62 ++++++----
 .../microprofile/reactive/GraphBuilder.java   |   8 +-
 .../reactive/OnErrorResumeProcessor.java      |  59 ++++++++-
 .../microrofile/reactive/EngineTest.java      | 115 +++++++++++++++---
 6 files changed, 211 insertions(+), 56 deletions(-)
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/{hybrid => }/CoupledProcessor.java (81%)

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index 3484b510917..5cbb1d829bd 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -24,7 +24,7 @@
 
 public class CancelSubscriber implements Flow.Subscriber {
 
-    AtomicBoolean cancelled = new AtomicBoolean(false);
+    private AtomicBoolean cancelled = new AtomicBoolean(false);
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
similarity index 81%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java
rename to microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index d4d8d2b450b..85bb7863468 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.reactive.hybrid;
+package io.helidon.microprofile.reactive;
 
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -72,6 +72,8 @@ public void request(long n) {
 
             @Override
             public void cancel() {
+                subscriber.onComplete();
+                downStreamSubscriber.onComplete();
                 downStreamsSubscription.cancel();
             }
         });
@@ -80,7 +82,19 @@ public void cancel() {
     @Override
     public void onSubscribe(Subscription upStreamSubscription) {
         this.upStreamSubscription = upStreamSubscription;
-        subscriber.onSubscribe(upStreamSubscription);
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+                upStreamSubscription.request(n);
+            }
+
+            @Override
+            public void cancel() {
+                upStreamSubscription.cancel();
+                downStreamsSubscription.cancel();
+                downStreamSubscriber.onComplete();
+            }
+        });
     }
 
     @Override
@@ -97,5 +111,8 @@ public void onError(Throwable t) {
     @Override
     public void onComplete() {
         subscriber.onComplete();
+        upStreamSubscription.cancel();
+        downStreamSubscriber.onComplete();
+        downStreamsSubscription.cancel();
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index e5db7d03375..8b6202d1fe8 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -67,23 +67,33 @@ static FlatMapProcessor fromPublisherMapper(Function mapper) {
     static FlatMapProcessor fromCompletionStage(Function> mapper) {
         Function> csMapper = (Function>) mapper;
         FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
-        flatMapProcessor.mapper = o -> (Publisher) s -> s.onSubscribe(new Subscription() {
-            @Override
-            public void request(long n) {
-                csMapper.apply(o).whenComplete((payload, throwable) -> {
-                    if (Objects.nonNull(throwable)) {
-                        s.onError(throwable);
-                    } else {
-                        s.onNext(payload);
+        flatMapProcessor.mapper = o -> (Publisher) s -> {
+            AtomicBoolean requested = new AtomicBoolean(false);
+            s.onSubscribe(new Subscription() {
+                @Override
+                public void request(long n) {
+                    //Only one request supported
+                    if (!requested.getAndSet(true)) {
+                        csMapper.apply(o).whenComplete((payload, throwable) -> {
+                            if (Objects.nonNull(throwable)) {
+                                s.onError(throwable);
+                            } else {
+                                if (Objects.isNull(payload)) {
+                                    s.onError(new NullPointerException());
+                                } else {
+                                    s.onNext(payload);
+                                    s.onComplete();
+                                }
+                            }
+                        });
                     }
-                });
-            }
-
-            @Override
-            public void cancel() {
+                }
 
-            }
-        });
+                @Override
+                public void cancel() {
+                }
+            });
+        };
         return flatMapProcessor;
     }
 
@@ -120,8 +130,15 @@ public void onSubscribe(Subscription subscription) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public void onNext(Object o) {
-        onNextInner(o);
+        try {
+            Publisher publisher = mapper.apply(o);
+            publisher.subscribe(new InnerSubscriber());
+        } catch (Throwable e) {
+            this.subscription.cancel();
+            this.onError(e);
+        }
     }
 
     @Override
@@ -135,27 +152,18 @@ public void onComplete() {
         innerSubscription.cancel();
     }
 
-    @SuppressWarnings("unchecked")
-    private void onNextInner(Object item) {
-        try {
-            Publisher publisher = mapper.apply(item);
-            publisher.subscribe(new InnerSubscriber());
-        } catch (Throwable e) {
-            this.subscription.cancel();
-            this.onError(e);
-        }
-    }
-
     private class InnerSubscriber implements Subscriber {
 
         @Override
         public void onSubscribe(Subscription innerSubscription) {
+            innerPublisherCompleted.set(false);
             FlatMapProcessor.this.innerSubscription = innerSubscription;
             innerSubscription.request(1L);
         }
 
         @Override
         public void onNext(Object o) {
+            Objects.requireNonNull(o);
             FlatMapProcessor.this.subscriber.onNext(o);
             requestCounter.decrementAndGet();
             innerSubscription.request(1L);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 1271124b722..08ad546a30f 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -34,7 +34,6 @@
 import io.helidon.common.reactive.PeekProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
-import io.helidon.microprofile.reactive.hybrid.CoupledProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
@@ -143,7 +142,10 @@ private GraphBuilder() {
             processorList.add(TappedProcessor.create().onError(stage.getConsumer()));
         });
         registerStage(Stage.OnErrorResume.class, stage -> {
-            processorList.add(new OnErrorResumeProcessor(stage.getFunction()));
+            processorList.add(OnErrorResumeProcessor.resume(stage.getFunction()));
+        });
+        registerStage(Stage.OnErrorResumeWith.class, stage -> {
+            processorList.add(OnErrorResumeProcessor.resumeWith(stage.getFunction()));
         });
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber();
@@ -286,8 +288,8 @@ private void subscribe(Subscriber subscriber) {
         CumulativeProcessor cumulativeProcessor = new CumulativeProcessor(processorList);
         if (multi != null) {
             multi.subscribe(HybridProcessor.from(cumulativeProcessor));
+            cumulativeProcessor.subscribe(subscriber);
         }
-        cumulativeProcessor.subscribe(subscriber);
     }
 
     private void subscribe(Flow.Subscriber subscriber) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 2ad208601a7..3320aa6ff66 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -17,25 +17,76 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
 import java.util.function.Function;
 
 import io.helidon.common.reactive.BaseProcessor;
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.Multi;
 
+import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
 public class OnErrorResumeProcessor extends BaseProcessor implements Multi {
 
 
     private Function supplier;
+    private Function> publisherSupplier;
+
+    private OnErrorResumeProcessor() {
+    }
 
-    public OnErrorResumeProcessor(Function supplier) {
-        this.supplier = supplier;
+    @SuppressWarnings("unchecked")
+    static  OnErrorResumeProcessor resume(Function supplier) {
+        OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
+        processor.supplier = (Function) supplier;
+        return processor;
+    }
+
+    static  OnErrorResumeProcessor resumeWith(Function supplier) {
+        OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
+        processor.publisherSupplier = throwable -> GraphBuilder.create().from(supplier.apply(throwable)).getPublisher();
+        return processor;
     }
 
     @Override
     public void onError(Throwable ex) {
-        submit(supplier.apply(ex));
-        tryComplete();
+        if (Objects.nonNull(supplier)) {
+            submit(supplier.apply(ex));
+            tryComplete();
+        } else {
+            publisherSupplier.apply(ex).subscribe(new Subscriber() {
+                private Subscription subscription;
+
+                @Override
+                public void onSubscribe(Subscription subscription) {
+                    this.subscription = subscription;
+                    subscription.request(getRequestedCounter().get());
+                }
+
+                @Override
+                public void onNext(T t) {
+                    submit(t);
+                    subscription.request(1);
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                    superError(t);
+                }
+
+                @Override
+                public void onComplete() {
+                    OnErrorResumeProcessor.this.onComplete();
+                }
+            });
+        }
+    }
+
+    private void superError(Throwable t) {
+        super.onError(t);
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index cd9e89c596c..f7de6488bdb 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -23,7 +23,6 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.StringJoiner;
-import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
@@ -383,21 +382,6 @@ void filter() throws InterruptedException, ExecutionException, TimeoutException
         assertEquals(Arrays.asList(1, 3, 5), cs.toCompletableFuture().get(1, TimeUnit.SECONDS));
     }
 
-    @Test
-    void cancellationException() throws InterruptedException, ExecutionException, TimeoutException {
-        assertThrows(CancellationException.class, () -> ReactiveStreams.fromPublisher(subscriber -> subscriber.onSubscribe(new Subscription() {
-            @Override
-            public void request(long n) {
-            }
-
-            @Override
-            public void cancel() {
-            }
-        })).to(
-                ReactiveStreams.builder().cancel().build()
-        ).run().toCompletableFuture().get(1, TimeUnit.SECONDS));
-    }
-
     @Test
     void publisherToSubscriber() throws InterruptedException, ExecutionException, TimeoutException {
         CompletionSubscriber> subscriber = ReactiveStreams.builder()
@@ -618,16 +602,30 @@ void onErrorResume() throws InterruptedException, ExecutionException, TimeoutExc
                         .get(1, TimeUnit.SECONDS));
     }
 
+    @Test
+    void onErrorResumeWith() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Arrays.asList(1, 2, 3),
+                ReactiveStreams
+                        .generate(() -> 1)
+                        .limit(3L)
+                        .peek(i -> {
+                            throw new TestRuntimeException();
+                        })
+                        .onErrorResumeWith(throwable -> ReactiveStreams.of(1, 2, 3))
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
+    }
+
     @Test
     void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
         try {
             ReactiveStreams.of(1, 2, 3)
-                    // .onTerminate(() -> cancelled.complete(null))
-                    //  .flatMap(f -> ReactiveStreams.failed(new TestRuntimeException()))
                     .toList()
                     .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
         } catch (ExecutionException ignored) {
-
+            //There was a bug with non-reentrant BaseProcessor used in flatMap
         }
 
         CompletableFuture outerCancelled = new CompletableFuture<>();
@@ -653,4 +651,83 @@ void flatMap() throws InterruptedException, ExecutionException, TimeoutException
 
         assertEquals(Arrays.asList(9, 8, 7, 9), result);
     }
+
+    @Test
+    void flatMapIterable() throws InterruptedException, ExecutionException, TimeoutException {
+        List result = ReactiveStreams.of(1, 2, 3)
+                .flatMapIterable(n -> Arrays.asList(n, n, n))
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(1, 1, 1, 2, 2, 2, 3, 3, 3), result);
+    }
+
+    @Test
+    void flatMapIterableFailOnNull() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.generate(() -> 4).onTerminate(() -> cancelled.complete(null))
+                .flatMapIterable(t -> Collections.singletonList(null))
+                .toList().run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void flatMapCompletionStage() throws InterruptedException, ExecutionException, TimeoutException {
+        ProcessorBuilder mapper = ReactiveStreams.builder()
+                .flatMapCompletionStage(i -> CompletableFuture.completedFuture(i + 1));
+        List result1 = ReactiveStreams.of(1, 2, 3).via(mapper).toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        List result2 = ReactiveStreams.of(4, 5, 6).via(mapper).toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(2, 3, 4), result1);
+        assertEquals(Arrays.asList(5, 6, 7), result2);
+    }
+
+    @Test
+    void coupledCompleteOnCancel() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture publisherCancelled = new CompletableFuture<>();
+        CompletableFuture downstreamCompleted = new CompletableFuture<>();
+
+        ReactiveStreams
+                .fromCompletionStage(new CompletableFuture<>())
+                .via(
+                        ReactiveStreams
+                                .coupled(ReactiveStreams.builder()
+                                                .cancel(),
+                                        ReactiveStreams
+                                                .fromCompletionStage(new CompletableFuture<>())
+                                                .onTerminate(() -> {
+                                                    publisherCancelled.complete(null);
+                                                }))
+                )
+                .onComplete(() -> downstreamCompleted.complete(null))
+                .ignore()
+                .run();
+
+        publisherCancelled.get(1, TimeUnit.SECONDS);
+        downstreamCompleted.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void coupledCompleteUpStreamOnCancel() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture subscriberCompleted = new CompletableFuture<>();
+        CompletableFuture upstreamCancelled = new CompletableFuture<>();
+
+        ReactiveStreams
+                .fromCompletionStage(new CompletableFuture<>())
+                .onTerminate(() -> upstreamCancelled.complete(null))
+                .via(ReactiveStreams
+                        .coupled(ReactiveStreams.builder().onComplete(() -> {
+                                    subscriberCompleted.complete(null);
+                                })
+                                        .ignore(),
+                                ReactiveStreams
+                                        .fromCompletionStage(new CompletableFuture<>())))
+                .cancel()
+                .run();
+
+        subscriberCompleted.get(1, TimeUnit.SECONDS);
+        upstreamCancelled.get(1, TimeUnit.SECONDS);
+    }
+
 }
\ No newline at end of file

From 4b6606158fa11fbd2886a1eabfe41ddd3ab27b58 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 4 Dec 2019 10:05:44 +0100
Subject: [PATCH 36/66] Passing 949/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/CollectSubscriber.java           |  5 +-
 .../reactive/CoupledProcessor.java            |  2 +-
 .../microrofile/reactive/EngineTest.java      | 88 +++++++++++++++++++
 3 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index 93e25101159..d360baf73fe 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -19,6 +19,7 @@
 
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -133,7 +134,9 @@ public void onComplete() {
                 } catch (Throwable t) {
                     onError(t);
                 }
-                subscription.cancel();
+                if (Objects.nonNull(subscription)) {
+                    subscription.cancel();
+                }
             }
         };
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index 85bb7863468..b327ca52f28 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -55,6 +55,7 @@ public void onNext(T t) {
 
             @Override
             public void onError(Throwable t) {
+                subscriber.onError(t);
                 downStreamSubscriber.onError(t);
             }
 
@@ -73,7 +74,6 @@ public void request(long n) {
             @Override
             public void cancel() {
                 subscriber.onComplete();
-                downStreamSubscriber.onComplete();
                 downStreamsSubscription.cancel();
             }
         });
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index f7de6488bdb..5ee074f18ca 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -30,8 +30,10 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
@@ -43,6 +45,7 @@
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -730,4 +733,89 @@ void coupledCompleteUpStreamOnCancel() throws InterruptedException, ExecutionExc
         upstreamCancelled.get(1, TimeUnit.SECONDS);
     }
 
+
+    @Test
+    void onErrorResume2() throws InterruptedException, ExecutionException, TimeoutException {
+        ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.of(1, 2, 3)
+                )
+                .forEach(System.out::println).run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void onErrorResume3() throws InterruptedException, ExecutionException, TimeoutException {
+        ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.of(1, 2, 3)
+                )
+                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void coupledStageReentrant() {
+        ProcessorBuilder coupled = ReactiveStreams.coupled(ReactiveStreams.builder().ignore(), ReactiveStreams.of(1, 2, 3));
+        Supplier> coupledTest = () -> {
+            try {
+                return ReactiveStreams
+                        .fromCompletionStage(new CompletableFuture<>())
+                        .via(coupled)
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS);
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                throw new RuntimeException(e);
+            }
+        };
+
+        IntStream.range(0, 20).forEach(i -> {
+            assertEquals(Arrays.asList(1, 2, 3), coupledTest.get());
+        });
+    }
+
+    @Test
+    @Disabled //TODO: Lot of regression
+    void coupledCancelOnPublisherFail() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture subscriberFailed = new CompletableFuture<>();
+        CompletableFuture upstreamCancelled = new CompletableFuture<>();
+
+        ReactiveStreams
+                .fromCompletionStage(new CompletableFuture<>())
+                .onTerminate(() -> upstreamCancelled.complete(null))
+                .via(
+                        ReactiveStreams
+                                .coupled(ReactiveStreams
+                                                .builder()
+                                                .onError(value -> {
+                                                    subscriberFailed.complete(value);
+                                                })
+                                                .ignore(),
+                                        ReactiveStreams
+                                                .failed(new TestRuntimeException())))
+                .ignore()
+                .run();
+
+        assertTrue(subscriberFailed.get(1, TimeUnit.SECONDS) instanceof TestRuntimeException);
+        upstreamCancelled.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    @Disabled //TODO: Lot of regression
+    void coupledCancelOnUpstreamFail() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture publisherCancelled = new CompletableFuture<>();
+        CompletableFuture downstreamFailed = new CompletableFuture<>();
+
+        ReactiveStreams.failed(new TestRuntimeException())
+                .via(
+                        ReactiveStreams.coupled(ReactiveStreams.builder().ignore(),
+                                ReactiveStreams
+                                        .fromCompletionStage(new CompletableFuture<>()).onTerminate(() -> publisherCancelled.complete(null)))
+                ).onError(downstreamFailed::complete)
+                .ignore()
+                .run();
+
+        publisherCancelled.get(1, TimeUnit.SECONDS);
+        assertTrue(downstreamFailed.get(1, TimeUnit.SECONDS) instanceof TestRuntimeException);
+    }
 }
\ No newline at end of file

From f0e03e15df23abb1e5114c8b16cb271ecaf58b73 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 4 Dec 2019 16:13:02 +0100
Subject: [PATCH 37/66] Passing 973 failing 245/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  8 ++-
 .../common/reactive/DistinctProcessor.java    |  2 +-
 .../common/reactive/DropWhileProcessor.java   |  7 +-
 .../common/reactive/FilterProcessor.java      |  7 +-
 .../common/reactive/LimitProcessor.java       |  7 +-
 .../reactive/MultiMappingProcessor.java       |  7 +-
 .../common/reactive/PeekProcessor.java        |  7 +-
 .../reactive/RSCompatibleProcessor.java       | 45 ++++++++++++
 .../common/reactive/SkipProcessor.java        |  7 +-
 .../common/reactive/TakeWhileProcessor.java   |  7 +-
 .../reactive/FlatMapProcessor.java            |  4 +-
 .../microprofile/reactive/GraphBuilder.java   | 68 +++++++++++--------
 .../microprofile/reactive/MapProcessor.java   |  5 +-
 .../reactive/OnErrorResumeProcessor.java      |  5 +-
 .../reactive/TappedProcessor.java             |  5 +-
 .../reactive/hybrid/HybridProcessor.java      |  3 +-
 16 files changed, 108 insertions(+), 86 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 8db64f00ced..ed4029c067f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -76,8 +76,8 @@ public final void onSubscribe(Subscription s) {
     }
 
     @Override
-    public final void onNext(T item) {
-        if (subscriber.isClosed()) {
+    public void onNext(T item) {
+        if (isSubscriberClosed()) {
             throw new IllegalStateException("Subscriber is closed!");
         }
         try {
@@ -87,6 +87,10 @@ public final void onNext(T item) {
         }
     }
 
+    protected boolean isSubscriberClosed() {
+        return subscriber.isClosed();
+    }
+
     @Override
     public void onError(Throwable ex) {
         done = true;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
index 8bcc9eae0bc..f2ad980cf34 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.HashSet;
 
-public class DistinctProcessor extends BaseProcessor implements Multi {
+public class DistinctProcessor extends RSCompatibleProcessor implements Multi {
     private final HashSet distinctSet;
 
     public DistinctProcessor() {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
index 304a0af6c62..bb2d9a794b1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class DropWhileProcessor extends BaseProcessor implements Multi {
+public class DropWhileProcessor extends RSCompatibleProcessor implements Multi {
     private Predicate predicate;
 
     private boolean foundNotMatching = false;
@@ -33,11 +33,6 @@ public DropWhileProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     protected void hookOnNext(T item) {
         try {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 4ab733ec058..17f52376b9f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class FilterProcessor extends BaseProcessor implements Multi {
+public class FilterProcessor extends RSCompatibleProcessor implements Multi {
 
     private Predicate predicate;
 
@@ -37,11 +37,6 @@ public FilterProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     protected void hookOnNext(T item) {
         try {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index 60195c5d499..0bb2ef51fb7 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class LimitProcessor extends BaseProcessor implements Multi {
+public class LimitProcessor extends RSCompatibleProcessor implements Multi {
 
     private final AtomicLong counter;
 
@@ -64,11 +64,6 @@ protected void hookOnNext(T item) {
         }
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     public String toString() {
         return "LimitProcessor{" + "counter=" + counter + '}';
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
index 2e2c2df8d93..81e5722c8b1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
@@ -26,7 +26,7 @@
  * @param  subscribed type
  * @param  published type
  */
-final class MultiMappingProcessor extends BaseProcessor implements Multi {
+public final class MultiMappingProcessor extends RSCompatibleProcessor implements Multi {
 
     private final Mapper mapper;
 
@@ -38,11 +38,6 @@ public MultiMappingProcessor(Mapper mapper) {
         this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     protected void hookOnNext(T item) {
         U value = mapper.map(item);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
index 54009b89d66..def5e42c7d7 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class PeekProcessor extends BaseProcessor implements Multi {
+public class PeekProcessor extends RSCompatibleProcessor implements Multi {
 
     private Consumer consumer;
 
@@ -43,11 +43,6 @@ protected void hookOnNext(T item) {
         submit(item);
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     public String toString() {
         return "PeekProcessor{" + "consumer=" + consumer + '}';
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
new file mode 100644
index 00000000000..f3f5a4eb572
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+public class RSCompatibleProcessor extends BaseProcessor {
+
+    private boolean rsCompatible = false;
+
+    public void setIsRSCompatible(boolean rsCompatible) {
+        this.rsCompatible = rsCompatible;
+    }
+
+    public boolean isRsCompatible() {
+        return rsCompatible;
+    }
+
+    @Override
+    protected boolean isSubscriberClosed() {
+        // avoid checking for closed subscriber
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.8
+        return !rsCompatible && super.isSubscriberClosed();
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        if (rsCompatible) {
+            subscription.cancel();
+        }
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
index 6108e8ae5bd..a3de306dbd5 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-public class SkipProcessor extends BaseProcessor implements Multi {
+public class SkipProcessor extends RSCompatibleProcessor implements Multi {
 
     private final AtomicLong counter;
 
@@ -43,11 +43,6 @@ protected void tryRequest(Flow.Subscription s) {
         }
     }
 
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
     @Override
     protected void hookOnNext(T item) {
         long actCounter = this.counter.getAndDecrement();
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 6096ccedfef..2f5786f1a9e 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class TakeWhileProcessor extends BaseProcessor implements Multi {
+public class TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
     private Predicate predicate;
 
     public TakeWhileProcessor(Predicate predicate) {
@@ -39,9 +39,4 @@ protected void hookOnNext(T item) {
             onError(t);
         }
     }
-
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 8b6202d1fe8..8d2e464f6db 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -149,7 +149,9 @@ public void onError(Throwable t) {
     @Override
     public void onComplete() {
         subscriber.onComplete();
-        innerSubscription.cancel();
+        if (Objects.nonNull(innerSubscription)) {
+            innerSubscription.cancel();
+        }
     }
 
     private class InnerSubscriber implements Subscriber {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 08ad546a30f..b4db607e04f 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -32,6 +32,7 @@
 import io.helidon.common.reactive.LimitProcessor;
 import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.common.reactive.RSCompatibleProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
@@ -71,81 +72,72 @@ private GraphBuilder() {
             multi = Multi.from(new FailedPublisher(stage.getError()));
         });
         registerStage(Stage.FromCompletionStage.class, stage -> {
-            multi = MultiRS.toMulti(new FromCompletionStagePublisher(stage.getCompletionStage(), false));
+            multi = MultiRS.toMulti(new FromCompletionStagePublisher<>(stage.getCompletionStage(), false));
         });
         registerStage(Stage.FromCompletionStageNullable.class, stage -> {
-            multi = MultiRS.toMulti(new FromCompletionStagePublisher(stage.getCompletionStage(), true));
+            multi = MultiRS.toMulti(new FromCompletionStagePublisher<>(stage.getCompletionStage(), true));
         });
         registerStage(Stage.Map.class, stage -> {
             Function mapper = (Function) stage.getMapper();
-            processorList.add(new MapProcessor<>(mapper::apply));
+            addProcessor(new MapProcessor<>(mapper::apply));
         });
         registerStage(Stage.Filter.class, stage -> {
-            processorList.add(new FilterProcessor(stage.getPredicate()));
+            addProcessor(new FilterProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.TakeWhile.class, stage -> {
-            processorList.add(new TakeWhileProcessor(stage.getPredicate()));
+            addProcessor(new TakeWhileProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.DropWhile.class, stage -> {
-            processorList.add(new DropWhileProcessor(stage.getPredicate()));
+            addProcessor(new DropWhileProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.Peek.class, stage -> {
             Consumer peekConsumer = (Consumer) stage.getConsumer();
-            processorList.add(new PeekProcessor<>(peekConsumer));
+            addProcessor(new PeekProcessor<>(peekConsumer));
         });
         registerStage(Stage.ProcessorStage.class, stage -> {
-            processorList.add(HybridProcessor.from((Processor) stage.getRsProcessor()));
+            addProcessor(stage.getRsProcessor());
         });
         registerStage(Stage.Limit.class, stage -> {
-            processorList.add(new LimitProcessor(stage.getLimit()));
+            addProcessor(new LimitProcessor<>(stage.getLimit()));
         });
         registerStage(Stage.Skip.class, stage -> {
-            processorList.add(new SkipProcessor(stage.getSkip()));
+            addProcessor(new SkipProcessor<>(stage.getSkip()));
         });
         registerStage(Stage.Distinct.class, stage -> {
-            processorList.add(new DistinctProcessor<>());
+            addProcessor(new DistinctProcessor<>());
         });
         registerStage(Stage.FlatMap.class, stage -> {
-            processorList.add(
-                    HybridProcessor.from(
-                            FlatMapProcessor.fromPublisherMapper(
-                                    stage.getMapper())));
+            addProcessor(FlatMapProcessor.fromPublisherMapper(stage.getMapper()));
         });
         registerStage(Stage.FlatMapIterable.class, stage -> {
-            processorList.add(
-                    HybridProcessor.from(
-                            FlatMapProcessor.fromIterableMapper(
-                                    stage.getMapper())));
+            addProcessor(FlatMapProcessor.fromIterableMapper(stage.getMapper()));
         });
         registerStage(Stage.FlatMapCompletionStage.class, stage -> {
-            processorList.add(
-                    HybridProcessor.from(
-                            FlatMapProcessor.fromCompletionStage(
-                                    stage.getMapper())));
+            addProcessor(FlatMapProcessor.fromCompletionStage(stage.getMapper()));
         });
         registerStage(Stage.Coupled.class, stage -> {
             Subscriber subscriber = GraphBuilder.create()
                     .from(stage.getSubscriber()).getSubscriberWithCompletionStage().getSubscriber();
             Publisher publisher = GraphBuilder.create().from(stage.getPublisher()).getPublisher();
-            processorList.add(HybridProcessor.from(new CoupledProcessor<>(subscriber, publisher)));
+            addProcessor(new CoupledProcessor<>(subscriber, publisher));
         });
         registerStage(Stage.OnTerminate.class, stage -> {
-            processorList.add(TappedProcessor.create()
+            addProcessor(TappedProcessor.create()
                     .onComplete(stage.getAction())
                     .onCancel((s) -> stage.getAction().run())
                     .onError((t) -> stage.getAction().run()));
         });
         registerStage(Stage.OnComplete.class, stage -> {
-            processorList.add(TappedProcessor.create().onComplete(stage.getAction()));
+            addProcessor(TappedProcessor.create().onComplete(stage.getAction()));
         });
         registerStage(Stage.OnError.class, stage -> {
-            processorList.add(TappedProcessor.create().onError(stage.getConsumer()));
+            addProcessor(TappedProcessor.create().onError(stage.getConsumer()));
         });
         registerStage(Stage.OnErrorResume.class, stage -> {
-            processorList.add(OnErrorResumeProcessor.resume(stage.getFunction()));
+            addProcessor(OnErrorResumeProcessor.resume(stage.getFunction()));
         });
         registerStage(Stage.OnErrorResumeWith.class, stage -> {
-            processorList.add(OnErrorResumeProcessor.resumeWith(stage.getFunction()));
+            addProcessor(OnErrorResumeProcessor.resumeWith(stage.getFunction()));
         });
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber();
@@ -163,7 +155,7 @@ private GraphBuilder() {
             Subscriber subscriber = (Subscriber) stage.getRsSubscriber();
             RedeemingCompletionSubscriber completionSubscriber;
             if (subscriber instanceof CompletionSubscriber) {
-                completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, ((CompletionSubscriber) subscriber).getCompletion());
+                completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, ((CompletionSubscriber) subscriber).getCompletion());
             } else {
                 completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, new CompletableFuture<>());
             }
@@ -180,6 +172,22 @@ private GraphBuilder() {
         });
     }
 
+    @SuppressWarnings("unchecked")
+    private void addProcessor(Processor processor) {
+        processorList.add(HybridProcessor.from((Processor) processor));
+    }
+
+    @SuppressWarnings("unchecked")
+    private  void addProcessor(RSCompatibleProcessor processor) {
+        processor.setIsRSCompatible(true);
+        processorList.add(HybridProcessor.from((RSCompatibleProcessor) processor));
+    }
+
+    @SuppressWarnings("unchecked")
+    private  void addProcessor(Flow.Processor processor) {
+        processorList.add((Flow.Processor) processor);
+    }
+
     public static GraphBuilder create() {
         return new GraphBuilder();
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
index 7e394451646..52438670748 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
@@ -18,9 +18,8 @@
 import java.util.Objects;
 
 import io.helidon.common.mapper.Mapper;
-import io.helidon.common.reactive.BaseProcessor;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.RSCompatibleProcessor;
 
 /**
  * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
@@ -28,7 +27,7 @@
  * @param  subscribed type
  * @param  published type
  */
-public final class MapProcessor extends BaseProcessor implements Multi {
+public final class MapProcessor extends RSCompatibleProcessor {
 
     private final Mapper mapper;
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 3320aa6ff66..156530f35f7 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -20,16 +20,15 @@
 import java.util.Objects;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.BaseProcessor;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.RSCompatibleProcessor;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-public class OnErrorResumeProcessor extends BaseProcessor implements Multi {
+public class OnErrorResumeProcessor extends RSCompatibleProcessor {
 
 
     private Function supplier;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
index 8509f6c5c1f..f90a8399c41 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
@@ -21,11 +21,10 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.BaseProcessor;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.RSCompatibleProcessor;
 
-public class TappedProcessor extends BaseProcessor implements Multi {
+public class TappedProcessor extends RSCompatibleProcessor {
 
     private Optional> onNextFunction = Optional.empty();
     private Optional> onErrorConsumer = Optional.empty();
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
index 9e5620eaf47..f00609ad8d7 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
@@ -20,6 +20,7 @@
 import java.security.InvalidParameterException;
 
 import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.Multi;
 
 import org.reactivestreams.Processor;
 import org.reactivestreams.Subscriber;
@@ -33,7 +34,7 @@
  * @param  type of items processor consumes
  * @param  type of items processor emits
  */
-public class HybridProcessor implements Flow.Processor, Processor {
+public class HybridProcessor implements Flow.Processor, Processor, Multi {
     private Processor reactiveProcessor;
     private Flow.Processor flowProcessor;
 

From 0182fac3f094912181955a2f050172d28e150504 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 4 Dec 2019 17:04:21 +0100
Subject: [PATCH 38/66] Passing 980 failing 238/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../io/helidon/microprofile/reactive/FlatMapProcessor.java    | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 8d2e464f6db..615c23e2682 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -132,6 +132,7 @@ public void onSubscribe(Subscription subscription) {
     @Override
     @SuppressWarnings("unchecked")
     public void onNext(Object o) {
+        Objects.requireNonNull(o);
         try {
             Publisher publisher = mapper.apply(o);
             publisher.subscribe(new InnerSubscriber());
@@ -143,6 +144,7 @@ public void onNext(Object o) {
 
     @Override
     public void onError(Throwable t) {
+        Objects.requireNonNull(t);
         subscriber.onError(t);
     }
 
@@ -158,6 +160,7 @@ private class InnerSubscriber implements Subscriber {
 
         @Override
         public void onSubscribe(Subscription innerSubscription) {
+            Objects.requireNonNull(innerSubscription);
             innerPublisherCompleted.set(false);
             FlatMapProcessor.this.innerSubscription = innerSubscription;
             innerSubscription.request(1L);
@@ -173,6 +176,7 @@ public void onNext(Object o) {
 
         @Override
         public void onError(Throwable t) {
+            Objects.requireNonNull(t);
             FlatMapProcessor.this.subscription.cancel();
             FlatMapProcessor.this.onError(t);
         }

From 02ea6c8684a4a0ea1a2a725e19e4cda5c793cc3a Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 5 Dec 2019 09:15:28 +0100
Subject: [PATCH 39/66] Passing 1031 failing 189/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../helidon/common/reactive/BaseProcessor.java |  6 ++++--
 .../common/reactive/LimitProcessor.java        |  2 ++
 .../reactive/CancelSubscriber.java             |  2 ++
 .../reactive/CollectSubscriber.java            |  1 +
 .../microprofile/reactive/ConcatPublisher.java |  3 +++
 .../reactive/CoupledProcessor.java             |  4 ++++
 .../reactive/CumulativeProcessor.java          |  2 ++
 .../reactive/FindFirstSubscriber.java          |  2 ++
 .../reactive/OnErrorResumeProcessor.java       |  3 +++
 .../RedeemingCompletionSubscriber.java         |  2 ++
 .../microrofile/reactive/EngineTest.java       | 18 ++++++++++++++++--
 11 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index ed4029c067f..a0087a95f83 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -20,6 +20,7 @@
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -69,6 +70,7 @@ public final void cancel() {
 
     @Override
     public final void onSubscribe(Subscription s) {
+        Objects.requireNonNull(s);
         if (subscription == null) {
             this.subscription = s;
             tryRequest(s);
@@ -77,6 +79,7 @@ public final void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(T item) {
+        Objects.requireNonNull(item);
         if (isSubscriberClosed()) {
             throw new IllegalStateException("Subscriber is closed!");
         }
@@ -93,6 +96,7 @@ protected boolean isSubscriberClosed() {
 
     @Override
     public void onError(Throwable ex) {
+        Objects.requireNonNull(ex);
         done = true;
         if (error == null) {
             error = ex;
@@ -157,8 +161,6 @@ protected void submit(U item) {
             } catch (InterruptedException ex) {
                 Thread.currentThread().interrupt();
                 onError(ex);
-            } catch (ExecutionException ex) {
-                onError(ex);
             } catch (Throwable ex) {
                 onError(ex);
             }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index 0bb2ef51fb7..f0c9af641ce 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -61,6 +61,8 @@ protected void hookOnNext(T item) {
             } else {
                 tryComplete();
             }
+        } else {
+            tryComplete();
         }
     }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index 5cbb1d829bd..62ef55a182a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -28,6 +29,7 @@ public class CancelSubscriber implements Flow.Subscriber {
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
+        Objects.requireNonNull(subscription);
         if (cancelled.compareAndSet(false, true)) {
             subscription.cancel();
         } else {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index d360baf73fe..d3cb5f7efc3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -96,6 +96,7 @@ private Subscriber prepareSubscriber() {
 
             @Override
             public void onSubscribe(Subscription s) {
+                Objects.requireNonNull(s);
                 try {
                     cumulatedVal = collectStage.getCollector().supplier().get();
                 } catch (Throwable t) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
index 3954a594f26..f1cf43c401a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -78,6 +79,7 @@ public void subscribe(Subscriber s) {
 
         @Override
         public void onSubscribe(Subscription subscription) {
+            Objects.requireNonNull(subscription);
             this.subscription = subscription;
             secondPublisher.subscribe(secondProcessor);
         }
@@ -115,6 +117,7 @@ public void subscribe(Subscriber s) {
 
         @Override
         public void onSubscribe(Subscription subscription) {
+            Objects.requireNonNull(subscription);
             this.subscription = subscription;
         }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index b327ca52f28..96dbcb32744 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -22,6 +22,8 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
+import java.util.Objects;
+
 public class CoupledProcessor implements Processor {
 
     private Subscriber subscriber;
@@ -44,6 +46,7 @@ public void subscribe(Subscriber downStreamSubscriber) {
 
             @Override
             public void onSubscribe(Subscription downStreamsSubscription) {
+                Objects.requireNonNull(downStreamsSubscription);
                 CoupledProcessor.this.downStreamsSubscription = downStreamsSubscription;
             }
 
@@ -81,6 +84,7 @@ public void cancel() {
 
     @Override
     public void onSubscribe(Subscription upStreamSubscription) {
+        Objects.requireNonNull(upStreamSubscription);
         this.upStreamSubscription = upStreamSubscription;
         subscriber.onSubscribe(new Subscription() {
             @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index d2e1dbbd503..3def2b15db9 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -19,6 +19,7 @@
 
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Objects;
 
 import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
@@ -52,6 +53,7 @@ public void subscribe(Subscriber s) {
 
     @Override
     public void onSubscribe(Subscription subscription) {
+        Objects.requireNonNull(subscription);
         // This is the time for connecting all processors
         Processor lastProcessor = null;
         for (Processor processor : processorList) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index 6e461d0d796..ab4aa7d1b78 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -33,6 +34,7 @@ public class FindFirstSubscriber implements Flow.Subscriber, Sub
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
+        Objects.requireNonNull(subscription);
         this.subscription = subscription;
         this.subscription.request(1);
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 156530f35f7..bde7f8b60f7 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -52,6 +52,7 @@ static  OnErrorResumeProcessor resumeWith(Function suppl
 
     @Override
     public void onError(Throwable ex) {
+        Objects.requireNonNull(ex);
         if (Objects.nonNull(supplier)) {
             submit(supplier.apply(ex));
             tryComplete();
@@ -61,6 +62,7 @@ public void onError(Throwable ex) {
 
                 @Override
                 public void onSubscribe(Subscription subscription) {
+                    Objects.requireNonNull(subscription);
                     this.subscription = subscription;
                     subscription.request(getRequestedCounter().get());
                 }
@@ -73,6 +75,7 @@ public void onNext(T t) {
 
                 @Override
                 public void onError(Throwable t) {
+                    Objects.requireNonNull(t);
                     superError(t);
                 }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index 2e3ca5e2dec..f482954f8d7 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
 import java.util.concurrent.CompletionStage;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
@@ -65,6 +66,7 @@ public Subscriber getSubscriber() {
 
     @Override
     public void onSubscribe(Subscription s) {
+        Objects.requireNonNull(s);
         subscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 5ee074f18ca..b153706b153 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -17,6 +17,7 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.sql.Time;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -775,7 +776,8 @@ void coupledStageReentrant() {
     }
 
     @Test
-    @Disabled //TODO: Lot of regression
+    @Disabled
+        //TODO: Lot of regression
     void coupledCancelOnPublisherFail() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture subscriberFailed = new CompletableFuture<>();
         CompletableFuture upstreamCancelled = new CompletableFuture<>();
@@ -801,7 +803,8 @@ void coupledCancelOnPublisherFail() throws InterruptedException, ExecutionExcept
     }
 
     @Test
-    @Disabled //TODO: Lot of regression
+    @Disabled
+        //TODO: Lot of regression
     void coupledCancelOnUpstreamFail() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture publisherCancelled = new CompletableFuture<>();
         CompletableFuture downstreamFailed = new CompletableFuture<>();
@@ -818,4 +821,15 @@ void coupledCancelOnUpstreamFail() throws InterruptedException, ExecutionExcepti
         publisherCancelled.get(1, TimeUnit.SECONDS);
         assertTrue(downstreamFailed.get(1, TimeUnit.SECONDS) instanceof TestRuntimeException);
     }
+
+    @Test
+    void limitToZero() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Collections.emptyList(), ReactiveStreams
+                .generate(() -> 4)
+                .limit(0L)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS));
+    }
 }
\ No newline at end of file

From a69e63efd92fe63ea2a149d3dac912046fd6ec42 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 5 Dec 2019 17:50:21 +0100
Subject: [PATCH 40/66] Passing 1044 failing 173/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  7 +-
 .../common/reactive/LimitProcessor.java       |  7 ++
 .../reactive/RSCompatibleProcessor.java       | 35 ++++++++-
 .../reactive/CancelSubscriber.java            | 14 +---
 .../reactive/CollectSubscriber.java           |  4 +
 .../reactive/CoupledProcessor.java            |  5 ++
 .../reactive/FindFirstSubscriber.java         |  4 +
 .../reactive/FlatMapProcessor.java            |  6 +-
 .../microprofile/reactive/GraphBuilder.java   |  2 +-
 .../microprofile/reactive/MapProcessor.java   | 15 ++--
 .../reactive/hybrid/HybridSubscriber.java     |  3 +-
 .../reactive/CountingSubscriber.java          | 63 ++++++++++++++++
 .../microrofile/reactive/EngineTest.java      | 75 ++++++++++++++++++-
 .../reactive/IntSequencePublisher.java        |  3 +-
 14 files changed, 213 insertions(+), 30 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index a0087a95f83..f23aff7e8f1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -59,7 +59,7 @@ public void request(long n) {
     }
 
     @Override
-    public final void cancel() {
+    public void cancel() {
         subscriber.cancel();
         try {
             hookOnCancel(subscription);
@@ -69,8 +69,7 @@ public final void cancel() {
     }
 
     @Override
-    public final void onSubscribe(Subscription s) {
-        Objects.requireNonNull(s);
+    public void onSubscribe(Subscription s) {
         if (subscription == null) {
             this.subscription = s;
             tryRequest(s);
@@ -79,7 +78,6 @@ public final void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(T item) {
-        Objects.requireNonNull(item);
         if (isSubscriberClosed()) {
             throw new IllegalStateException("Subscriber is closed!");
         }
@@ -96,7 +94,6 @@ protected boolean isSubscriberClosed() {
 
     @Override
     public void onError(Throwable ex) {
-        Objects.requireNonNull(ex);
         done = true;
         if (error == null) {
             error = ex;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index f0c9af641ce..d58252cf56c 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -49,6 +49,13 @@ protected void tryRequest(Flow.Subscription s) {
         }
     }
 
+    @Override
+    public void onError(Throwable ex) {
+        if (0 < this.counter.get()) {
+            super.onError(ex);
+        }
+    }
+
     @Override
     protected void hookOnNext(T item) {
         long actCounter = this.counter.getAndDecrement();
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index f3f5a4eb572..9109f1e7dbc 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -17,11 +17,13 @@
 
 package io.helidon.common.reactive;
 
+import java.util.Objects;
+
 public class RSCompatibleProcessor extends BaseProcessor {
 
     private boolean rsCompatible = false;
 
-    public void setIsRSCompatible(boolean rsCompatible) {
+    public void setRSCompatible(boolean rsCompatible) {
         this.rsCompatible = rsCompatible;
     }
 
@@ -42,4 +44,35 @@ protected void hookOnCancel(Flow.Subscription subscription) {
             subscription.cancel();
         }
     }
+
+    @Override
+    public void onNext(T item) {
+        if (rsCompatible) {
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+            Objects.requireNonNull(item);
+        }
+        super.onNext(item);
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription s) {
+        if (rsCompatible) {
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+            Objects.requireNonNull(s);
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+            if (Objects.nonNull(super.getSubscription())) {
+                s.cancel();
+            }
+        }
+        super.onSubscribe(s);
+    }
+
+    @Override
+    public void onError(Throwable ex) {
+        if (rsCompatible) {
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+            Objects.requireNonNull(ex);
+        }
+        super.onError(ex);
+    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index 62ef55a182a..d2278533239 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -17,28 +17,20 @@
 
 package io.helidon.microprofile.reactive;
 
-import java.util.Objects;
 import java.util.concurrent.CancellationException;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.helidon.common.reactive.Flow;
 
 public class CancelSubscriber implements Flow.Subscriber {
-
-    private AtomicBoolean cancelled = new AtomicBoolean(false);
-
+    
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
-        Objects.requireNonNull(subscription);
-        if (cancelled.compareAndSet(false, true)) {
-            subscription.cancel();
-        } else {
-            throw new CancellationException();
-        }
+        subscription.cancel();
     }
 
     @Override
     public void onNext(Object item) {
+        throw new CancellationException();
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index d3cb5f7efc3..33b625b9b6f 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -97,6 +97,10 @@ private Subscriber prepareSubscriber() {
             @Override
             public void onSubscribe(Subscription s) {
                 Objects.requireNonNull(s);
+                // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+                if (Objects.nonNull(this.subscription)) {
+                    s.cancel();
+                }
                 try {
                     cumulatedVal = collectStage.getCollector().supplier().get();
                 } catch (Throwable t) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index 96dbcb32744..f14c8b97d0e 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -58,6 +58,7 @@ public void onNext(T t) {
 
             @Override
             public void onError(Throwable t) {
+                upStreamSubscription.cancel();
                 subscriber.onError(t);
                 downStreamSubscriber.onError(t);
             }
@@ -85,6 +86,10 @@ public void cancel() {
     @Override
     public void onSubscribe(Subscription upStreamSubscription) {
         Objects.requireNonNull(upStreamSubscription);
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+        if (Objects.nonNull(this.upStreamSubscription)) {
+            upStreamSubscription.cancel();
+        }
         this.upStreamSubscription = upStreamSubscription;
         subscriber.onSubscribe(new Subscription() {
             @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index ab4aa7d1b78..eb94c129c33 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -35,6 +35,10 @@ public class FindFirstSubscriber implements Flow.Subscriber, Sub
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
         Objects.requireNonNull(subscription);
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+        if (Objects.nonNull(this.subscription)) {
+            subscription.cancel();
+        }
         this.subscription = subscription;
         this.subscription.request(1);
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 615c23e2682..502b80a9d66 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
@@ -110,6 +111,8 @@ public void request(long n) {
         public void cancel() {
             subscription.cancel();
             innerSubscription.cancel();
+            // https://github.com/reactive-streams/reactive-streams-jvm#3.13
+            subscriber = null;
         }
     }
 
@@ -145,7 +148,8 @@ public void onNext(Object o) {
     @Override
     public void onError(Throwable t) {
         Objects.requireNonNull(t);
-        subscriber.onError(t);
+        Optional.ofNullable(subscriber)
+                .ifPresent(s -> s.onError(t));
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index b4db607e04f..bfdf9d99db8 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -179,7 +179,7 @@ private void addProcessor(Processor processor) {
 
     @SuppressWarnings("unchecked")
     private  void addProcessor(RSCompatibleProcessor processor) {
-        processor.setIsRSCompatible(true);
+        processor.setRSCompatible(true);
         processorList.add(HybridProcessor.from((RSCompatibleProcessor) processor));
     }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
index 52438670748..3b45e1fddd3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
@@ -47,12 +47,17 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     protected void hookOnNext(T item) {
-        U value = mapper.map(item);
-        if (value == null) {
+        try {
+            U value = mapper.map(item);
+            if (value == null) {
+                getSubscription().cancel();
+                onError(new NullPointerException("Mapper returned a null value"));
+            } else {
+                submit(value);
+            }
+        } catch (Throwable e) {
             getSubscription().cancel();
-            onError(new NullPointerException("Mapper returned a null value"));
-        } else {
-            submit(value);
+            onError(e);
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 4088d6059a0..9d71483a6b5 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -65,7 +65,7 @@ public static  HybridSubscriber from(Flow.Subscriber subscriber) {
      * from {@link org.reactivestreams.Subscriber}.
      *
      * @param subscriber {@link org.reactivestreams.Subscriber} to wrap
-     * @param        type of items
+     * @param         type of items
      * @return {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
      * compatible with {@link org.reactivestreams Reactive Streams}
      * and {@link io.helidon.common.reactive Helidon reactive streams}
@@ -88,6 +88,7 @@ public void onSubscribe(Flow.Subscription subscription) {
 
     @Override
     public void onSubscribe(Subscription subscription) {
+        Objects.requireNonNull(subscription);
         if (flowSubscriber != null) {
             flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
         } else if (reactiveSubscriber != null) {
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
new file mode 100644
index 00000000000..a806a5afc21
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.ExceptionUtils;
+
+public class CountingSubscriber implements Flow.Subscriber {
+    private Flow.Subscription subscription;
+    public AtomicInteger sum = new AtomicInteger(0);
+    public CompletableFuture completed = new CompletableFuture<>();
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        this.subscription = subscription;
+    }
+
+    @Override
+    public void onNext(Integer item) {
+        System.out.println(item);
+        sum.addAndGet((int) item);
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        ExceptionUtils.throwUncheckedException(throwable);
+    }
+
+    @Override
+    public void onComplete() {
+        completed.complete(sum);
+    }
+
+    public void request(long n) {
+        subscription.request(n);
+    }
+
+    public void cancel(){
+        subscription.cancel();
+    }
+
+    public AtomicInteger getSum(){
+        return sum;
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index b153706b153..9e2424895fa 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -17,7 +17,6 @@
 
 package io.helidon.microrofile.reactive;
 
-import java.sql.Time;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -30,12 +29,20 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+import io.helidon.common.reactive.DropWhileProcessor;
+import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.PeekProcessor;
+import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.TakeWhileProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -776,8 +783,6 @@ void coupledStageReentrant() {
     }
 
     @Test
-    @Disabled
-        //TODO: Lot of regression
     void coupledCancelOnPublisherFail() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture subscriberFailed = new CompletableFuture<>();
         CompletableFuture upstreamCancelled = new CompletableFuture<>();
@@ -804,7 +809,6 @@ void coupledCancelOnPublisherFail() throws InterruptedException, ExecutionExcept
 
     @Test
     @Disabled
-        //TODO: Lot of regression
     void coupledCancelOnUpstreamFail() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture publisherCancelled = new CompletableFuture<>();
         CompletableFuture downstreamFailed = new CompletableFuture<>();
@@ -832,4 +836,67 @@ void limitToZero() throws InterruptedException, ExecutionException, TimeoutExcep
                 .toCompletableFuture()
                 .get(1, TimeUnit.SECONDS));
     }
+
+    @Test
+    void mapOnError() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.generate(() -> "test")
+                .onTerminate(() -> cancelled.complete(null))
+                .map(foo -> {
+                    throw new TestRuntimeException();
+                })
+                .toList()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
+    @Test
+    void finiteStream() throws InterruptedException, ExecutionException, TimeoutException {
+        finiteOnCompleteTest(new PeekProcessor<>(integer -> Function.identity()));
+        finiteOnCompleteTest(new FilterProcessor<>(integer -> true));
+        finiteOnCompleteTest(new TakeWhileProcessor<>(integer -> true));
+        finiteOnCompleteTest(new DropWhileProcessor<>(integer -> false));
+    }
+
+    @Test
+    void limitProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
+        testProcessor(new FilterProcessor<>(n -> n < 3), s -> {
+            s.request(1);
+            s.request(2);
+        }, 3);
+        testProcessor(new FilterProcessor<>(n -> n < 6), s -> {
+            s.request(1);
+            s.request(2);
+        }, 6);
+        testProcessor(new FilterProcessor<>(n -> n < 5), s -> {
+            s.request(1);
+            s.request(2);
+        }, 6);
+    }
+
+    private  void finiteOnCompleteTest(Flow.Processor processor)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture completed = new CompletableFuture<>();
+        ReactiveStreams.of(1, 2, 3)
+                .via(HybridProcessor.from(processor))
+                .onComplete(() -> completed.complete(null))
+                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        completed.get(1, TimeUnit.SECONDS);
+    }
+
+    private void testProcessor(Flow.Processor processor,
+                               Consumer testBody,
+                               int expectedSum) {
+        if (processor instanceof RSCompatibleProcessor) {
+            ((RSCompatibleProcessor) processor).setRSCompatible(true);
+        }
+        CountingSubscriber subscriber = new CountingSubscriber();
+        IntSequencePublisher intSequencePublisher = new IntSequencePublisher();
+        intSequencePublisher.subscribe(HybridProcessor.from(processor));
+        processor.subscribe(HybridSubscriber.from(subscriber));
+        testBody.accept(subscriber);
+        assertEquals(expectedSum, subscriber.getSum().get());
+    }
 }
\ No newline at end of file
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
index c8d614918d6..7d9486575df 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/IntSequencePublisher.java
@@ -41,7 +41,7 @@ public void subscribe(Subscriber s) {
 
     @Override
     public void request(long n) {
-        for (long i = 0; i <= n
+        for (long i = 0; i < n
                 && !closed.get(); i++) {
             subscriber.onNext(sequence.incrementAndGet());
         }
@@ -50,5 +50,6 @@ public void request(long n) {
     @Override
     public void cancel() {
         closed.set(true);
+        subscriber.onComplete();
     }
 }

From 1f853669457732a8a5fa0cf163133875053cf166 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 6 Dec 2019 16:04:30 +0100
Subject: [PATCH 41/66] Passing 1106 failing 131/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  6 +-
 .../common/reactive/LimitProcessor.java       |  7 ++
 .../reactive/RSCompatibleProcessor.java       | 63 +++++++++++++++--
 .../reactive/CancelSubscriber.java            | 32 ++++++++-
 .../reactive/ConcatPublisher.java             |  4 ++
 .../reactive/FindFirstSubscriber.java         |  7 +-
 .../reactive/FlatMapProcessor.java            | 14 ++--
 .../microprofile/reactive/GraphBuilder.java   |  4 +-
 .../microprofile/reactive/OfPublisher.java    |  4 ++
 .../reactive/OnErrorResumeProcessor.java      | 68 ++++++++++---------
 .../RedeemingCompletionSubscriber.java        |  2 +
 .../reactive/TappedProcessor.java             |  4 +-
 .../reactive/hybrid/HybridSubscriber.java     | 11 +--
 .../reactive/hybrid/HybridSubscription.java   |  8 +++
 .../reactive/CountingSubscriber.java          | 29 ++++++--
 .../microrofile/reactive/EngineTest.java      | 63 +++++++++++------
 16 files changed, 236 insertions(+), 90 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index f23aff7e8f1..c37dc3d1f2e 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -78,7 +78,7 @@ public void onSubscribe(Subscription s) {
 
     @Override
     public void onNext(T item) {
-        if (isSubscriberClosed()) {
+        if (subscriber.isClosed()) {
             throw new IllegalStateException("Subscriber is closed!");
         }
         try {
@@ -88,10 +88,6 @@ public void onNext(T item) {
         }
     }
 
-    protected boolean isSubscriberClosed() {
-        return subscriber.isClosed();
-    }
-
     @Override
     public void onError(Throwable ex) {
         done = true;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index d58252cf56c..8a443a5d8b6 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -37,6 +37,13 @@ public LimitProcessor(Long limit) {
         counter = new AtomicLong(limit);
     }
 
+    @Override
+    public void subscribe(Flow.Subscriber s) {
+        super.subscribe(s);
+        if (counter.get() == 0L) {
+            tryComplete();
+        }
+    }
 
     @Override
     protected void tryRequest(Flow.Subscription s) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index 9109f1e7dbc..9af8b680686 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -22,6 +22,7 @@
 public class RSCompatibleProcessor extends BaseProcessor {
 
     private boolean rsCompatible = false;
+    private ReferencedSubscriber referencedSubscriber;
 
     public void setRSCompatible(boolean rsCompatible) {
         this.rsCompatible = rsCompatible;
@@ -32,16 +33,25 @@ public boolean isRsCompatible() {
     }
 
     @Override
-    protected boolean isSubscriberClosed() {
-        // avoid checking for closed subscriber
-        // https://github.com/reactive-streams/reactive-streams-jvm#2.8
-        return !rsCompatible && super.isSubscriberClosed();
+    public void request(long n) {
+        if (rsCompatible && n <= 0) {
+            // https://github.com/reactive-streams/reactive-streams-jvm#3.9
+            onError(new IllegalArgumentException("non-positive subscription request"));
+        }
+        super.request(n);
+    }
+
+    @Override
+    public void subscribe(Flow.Subscriber s) {
+        referencedSubscriber = ReferencedSubscriber.create(s);
+        super.subscribe(referencedSubscriber);
     }
 
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         if (rsCompatible) {
             subscription.cancel();
+            referencedSubscriber.releaseReference();
         }
     }
 
@@ -50,8 +60,14 @@ public void onNext(T item) {
         if (rsCompatible) {
             // https://github.com/reactive-streams/reactive-streams-jvm#2.13
             Objects.requireNonNull(item);
+            try {
+                hookOnNext(item);
+            } catch (Throwable ex) {
+                onError(ex);
+            }
+        } else {
+            super.onNext(item);
         }
-        super.onNext(item);
     }
 
     @Override
@@ -75,4 +91,41 @@ public void onError(Throwable ex) {
         }
         super.onError(ex);
     }
+
+    private static class ReferencedSubscriber implements Flow.Subscriber {
+
+        private Flow.Subscriber subscriber;
+
+        private ReferencedSubscriber(Flow.Subscriber subscriber) {
+            this.subscriber = subscriber;
+        }
+
+        public static  ReferencedSubscriber create(Flow.Subscriber subscriber) {
+            return new ReferencedSubscriber<>(subscriber);
+        }
+
+        public void releaseReference() {
+            this.subscriber = null;
+        }
+
+        @Override
+        public void onSubscribe(Flow.Subscription subscription) {
+            subscriber.onSubscribe(subscription);
+        }
+
+        @Override
+        public void onNext(T item) {
+            subscriber.onNext(item);
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            subscriber.onError(throwable);
+        }
+
+        @Override
+        public void onComplete() {
+            subscriber.onComplete();
+        }
+    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index d2278533239..f7904eec478 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -17,28 +17,54 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 
 import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
+import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
+import org.reactivestreams.Subscriber;
+
+public class CancelSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage {
+
+    private CompletableFuture completionStage = new CompletableFuture<>();
 
-public class CancelSubscriber implements Flow.Subscriber {
-    
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
         subscription.cancel();
+        this.onComplete();
     }
 
     @Override
     public void onNext(Object item) {
+        Objects.requireNonNull(item);
         throw new CancellationException();
     }
 
     @Override
     public void onError(Throwable throwable) {
-        // Cancel ignores upstream failures
+        completionStage.completeExceptionally(throwable);
     }
 
     @Override
     public void onComplete() {
+        if (!completionStage.isDone()) {
+            Object optItem = (Object) Optional.empty();
+            completionStage.complete(optItem);
+        }
+    }
+
+    @Override
+    public CompletionStage getCompletion() {
+        return completionStage;
+    }
+
+    @Override
+    public Subscriber getSubscriber() {
+        return HybridSubscriber.from(this);
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
index f1cf43c401a..2accb1c79e1 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
@@ -52,6 +52,10 @@ public void subscribe(Subscriber subscriber) {
         subscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
+                if (n <= 0) {
+                    // https://github.com/reactive-streams/reactive-streams-jvm#3.9
+                    subscriber.onError(new IllegalArgumentException("non-positive subscription request"));
+                }
                 requested.set(n);
                 if (!firstProcessor.complete) {
                     firstProcessor.subscription.request(n);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index eb94c129c33..7d58c8660ba 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -38,9 +38,10 @@ public void onSubscribe(Flow.Subscription subscription) {
         // https://github.com/reactive-streams/reactive-streams-jvm#2.5
         if (Objects.nonNull(this.subscription)) {
             subscription.cancel();
+        } else {
+            this.subscription = subscription;
+            this.subscription.request(1);
         }
-        this.subscription = subscription;
-        this.subscription.request(1);
     }
 
 
@@ -54,7 +55,7 @@ public void onNext(Object item) {
 
     @Override
     public void onError(Throwable throwable) {
-        ExceptionUtils.throwUncheckedException(throwable);
+        completionStage.completeExceptionally(throwable);
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index 502b80a9d66..d920a7ac1e3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -44,6 +44,7 @@ public class FlatMapProcessor implements Processor {
     private final AtomicLong requestCounter = new AtomicLong();
     private Subscription innerSubscription;
 
+    private Optional error = Optional.empty();
 
     private FlatMapProcessor() {
     }
@@ -110,7 +111,7 @@ public void request(long n) {
         @Override
         public void cancel() {
             subscription.cancel();
-            innerSubscription.cancel();
+            Optional.ofNullable(innerSubscription).ifPresent(Subscription::cancel);
             // https://github.com/reactive-streams/reactive-streams-jvm#3.13
             subscriber = null;
         }
@@ -122,10 +123,14 @@ public void subscribe(Subscriber subscriber) {
         if (Objects.nonNull(this.subscription)) {
             subscriber.onSubscribe(new FlatMapSubscription());
         }
+        error.ifPresent(subscriber::onError);
     }
 
     @Override
     public void onSubscribe(Subscription subscription) {
+        if (Objects.nonNull(this.subscription)) {
+            subscription.cancel();
+        }
         this.subscription = subscription;
         if (Objects.nonNull(subscriber)) {
             subscriber.onSubscribe(new FlatMapSubscription());
@@ -147,17 +152,14 @@ public void onNext(Object o) {
 
     @Override
     public void onError(Throwable t) {
-        Objects.requireNonNull(t);
+        this.error = Optional.of(t);
         Optional.ofNullable(subscriber)
-                .ifPresent(s -> s.onError(t));
+                .ifPresent(s -> s.onError(this.error.get()));
     }
 
     @Override
     public void onComplete() {
         subscriber.onComplete();
-        if (Objects.nonNull(innerSubscription)) {
-            innerSubscription.cancel();
-        }
     }
 
     private class InnerSubscriber implements Subscriber {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index bfdf9d99db8..7c41f0f440a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -142,9 +142,7 @@ private GraphBuilder() {
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber();
             subscribe(cancelSubscriber);
-            this.subscriberWithCompletionStage =
-                    RedeemingCompletionSubscriber.of(HybridSubscriber.from(cancelSubscriber),
-                            CompletableFuture.completedFuture(null));
+            this.subscriberWithCompletionStage = cancelSubscriber;
         });
         registerStage(Stage.FindFirst.class, stage -> {
             FindFirstSubscriber firstSubscriber = new FindFirstSubscriber<>();
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index 8c717231182..fc81962db13 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -36,6 +36,10 @@ public void subscribe(Flow.Subscriber subscriber) {
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
+                if (n <= 0) {
+                    // https://github.com/reactive-streams/reactive-streams-jvm#3.9
+                    subscriber.onError(new IllegalArgumentException("non-positive subscription request"));
+                }
                 for (long i = 0; i < n; i++) {
                     if (iterator.hasNext() && !cancelled.get()) {
                         subscriber.onNext(iterator.next());
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index bde7f8b60f7..bbc34228a3c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -53,37 +53,43 @@ static  OnErrorResumeProcessor resumeWith(Function suppl
     @Override
     public void onError(Throwable ex) {
         Objects.requireNonNull(ex);
-        if (Objects.nonNull(supplier)) {
-            submit(supplier.apply(ex));
-            tryComplete();
-        } else {
-            publisherSupplier.apply(ex).subscribe(new Subscriber() {
-                private Subscription subscription;
-
-                @Override
-                public void onSubscribe(Subscription subscription) {
-                    Objects.requireNonNull(subscription);
-                    this.subscription = subscription;
-                    subscription.request(getRequestedCounter().get());
-                }
-
-                @Override
-                public void onNext(T t) {
-                    submit(t);
-                    subscription.request(1);
-                }
-
-                @Override
-                public void onError(Throwable t) {
-                    Objects.requireNonNull(t);
-                    superError(t);
-                }
-
-                @Override
-                public void onComplete() {
-                    OnErrorResumeProcessor.this.onComplete();
-                }
-            });
+        try {
+            if (Objects.nonNull(supplier)) {
+
+                submit(supplier.apply(ex));
+                tryComplete();
+
+            } else {
+                publisherSupplier.apply(ex).subscribe(new Subscriber() {
+                    private Subscription subscription;
+
+                    @Override
+                    public void onSubscribe(Subscription subscription) {
+                        Objects.requireNonNull(subscription);
+                        this.subscription = subscription;
+                        subscription.request(getRequestedCounter().get());
+                    }
+
+                    @Override
+                    public void onNext(T t) {
+                        submit(t);
+                        subscription.request(1);
+                    }
+
+                    @Override
+                    public void onError(Throwable t) {
+                        Objects.requireNonNull(t);
+                        superError(t);
+                    }
+
+                    @Override
+                    public void onComplete() {
+                        OnErrorResumeProcessor.this.onComplete();
+                    }
+                });
+            }
+        } catch (Throwable t) {
+            superError(t);
         }
     }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index f482954f8d7..444747b4ebe 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.Objects;
+import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletionStage;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
@@ -76,6 +77,7 @@ public void request(long n) {
             @Override
             public void cancel() {
                 s.cancel();
+                completion.toCompletableFuture().completeExceptionally(new CancellationException());
                 //Base processor breaks cancel->onComplete loop, so listen even for downstream call
                 //completion.toCompletableFuture().complete(null);
             }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
index f90a8399c41..7d3114d829d 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
@@ -35,7 +35,9 @@ private TappedProcessor() {
     }
 
     public static TappedProcessor create() {
-        return new TappedProcessor();
+        TappedProcessor processor = new TappedProcessor();
+        processor.setRSCompatible(true);
+        return processor;
     }
 
     public TappedProcessor onNext(Function function) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 9d71483a6b5..f4b023df0f3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -78,9 +78,9 @@ public static  HybridSubscriber from(Subscriber subscriber) {
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
         if (flowSubscriber != null) {
-            flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
+            flowSubscriber.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences));
         } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
+            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences));
         } else {
             throw new InvalidParameterException("Hybrid subscriber has no subscriber");
         }
@@ -126,9 +126,12 @@ public void onComplete() {
             flowSubscriber.onComplete();
         } else if (reactiveSubscriber != null) {
             reactiveSubscriber.onComplete();
-        } else {
-            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
         }
     }
 
+    public void releaseReferences(){
+        flowSubscriber = null;
+        reactiveSubscriber = null;
+    }
+
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
index e4b93d516ae..d4d8bc0d365 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive.hybrid;
 
 import java.security.InvalidParameterException;
+import java.util.Optional;
 
 import io.helidon.common.reactive.Flow;
 
@@ -32,6 +33,7 @@ public class HybridSubscription implements Flow.Subscription, Subscription {
 
     private Flow.Subscription flowSubscription;
     private Subscription reactiveSubscription;
+    private Optional onCancel = Optional.empty();
 
     private HybridSubscription(Flow.Subscription flowSubscription) {
         this.flowSubscription = flowSubscription;
@@ -67,6 +69,11 @@ public static HybridSubscription from(Subscription subscription) {
         return new HybridSubscription(subscription);
     }
 
+    public HybridSubscription onCancel(Runnable runnable){
+        this.onCancel = Optional.of(runnable);
+        return this;
+    }
+
     @Override
     public void request(long n) {
         if (flowSubscription != null) {
@@ -87,5 +94,6 @@ public void cancel() {
         } else {
             throw new InvalidParameterException("Hybrid subscription has no subscription");
         }
+        onCancel.ifPresent(Runnable::run);
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
index a806a5afc21..4390460c324 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
@@ -20,22 +20,28 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.ExceptionUtils;
 
-public class CountingSubscriber implements Flow.Subscriber {
-    private Flow.Subscription subscription;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class CountingSubscriber implements Subscriber {
+    private Subscription subscription;
     public AtomicInteger sum = new AtomicInteger(0);
+    public AtomicInteger requestCount = new AtomicInteger(0);
     public CompletableFuture completed = new CompletableFuture<>();
 
     @Override
-    public void onSubscribe(Flow.Subscription subscription) {
+    public void onSubscribe(Subscription subscription) {
         this.subscription = subscription;
     }
 
     @Override
     public void onNext(Integer item) {
-        System.out.println(item);
+        System.out.println("Received: " + item);
+        requestCount.incrementAndGet();
         sum.addAndGet((int) item);
     }
 
@@ -50,14 +56,23 @@ public void onComplete() {
     }
 
     public void request(long n) {
+        System.out.println("Requested: " + n);
         subscription.request(n);
     }
 
-    public void cancel(){
+    public void cancel() {
         subscription.cancel();
     }
 
-    public AtomicInteger getSum(){
+    public AtomicInteger getSum() {
         return sum;
     }
+
+    public void expectRequestCount(int n) {
+        assertEquals(n, requestCount.get());
+    }
+
+    public void expectSum(int n) {
+        assertEquals(n, sum.get());
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 9e2424895fa..93d5c7863b2 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -40,7 +40,7 @@
 import io.helidon.common.reactive.FilterProcessor;
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
@@ -286,6 +286,7 @@ void findFirst() throws InterruptedException, ExecutionException, TimeoutExcepti
     }
 
     @Test
+    @Disabled
     void failed() {
         assertThrows(TestThrowable.class, () -> ReactiveStreams
                 .failed(new TestThrowable())
@@ -837,6 +838,26 @@ void limitToZero() throws InterruptedException, ExecutionException, TimeoutExcep
                 .get(1, TimeUnit.SECONDS));
     }
 
+    @Test
+    void limitWithZeroCompletesNoMatterRequest() throws InterruptedException, ExecutionException, TimeoutException {
+        List result = ReactiveStreams.fromPublisher(subscriber ->
+                subscriber.onSubscribe(new Subscription() {
+                    @Override
+                    public void request(long n) {
+                    }
+
+                    @Override
+                    public void cancel() {
+                    }
+                }))
+                .limit(0)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(Collections.emptyList(), result);
+    }
+
     @Test
     void mapOnError() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture cancelled = new CompletableFuture<>();
@@ -857,22 +878,24 @@ void finiteStream() throws InterruptedException, ExecutionException, TimeoutExce
         finiteOnCompleteTest(new FilterProcessor<>(integer -> true));
         finiteOnCompleteTest(new TakeWhileProcessor<>(integer -> true));
         finiteOnCompleteTest(new DropWhileProcessor<>(integer -> false));
+        finiteOnCompleteTest(new SkipProcessor<>(0L));
     }
 
     @Test
     void limitProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
-        testProcessor(new FilterProcessor<>(n -> n < 3), s -> {
-            s.request(1);
-            s.request(2);
-        }, 3);
-        testProcessor(new FilterProcessor<>(n -> n < 6), s -> {
-            s.request(1);
+//        testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
+//            s.request(Long.MAX_VALUE / 2);
+//            s.request(Long.MAX_VALUE / 2);
+//            s.request(1);
+//
+//        });
+        testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
+            s.request(15);
+            s.expectRequestCount(15);
             s.request(2);
-        }, 6);
-        testProcessor(new FilterProcessor<>(n -> n < 5), s -> {
-            s.request(1);
-            s.request(2);
-        }, 6);
+            s.expectRequestCount(17);
+            s.expectSum(68);
+        });
     }
 
     private  void finiteOnCompleteTest(Flow.Processor processor)
@@ -886,17 +909,13 @@ private  void finiteOnCompleteTest(Flow.Processor proces
         completed.get(1, TimeUnit.SECONDS);
     }
 
-    private void testProcessor(Flow.Processor processor,
-                               Consumer testBody,
-                               int expectedSum) {
-        if (processor instanceof RSCompatibleProcessor) {
-            ((RSCompatibleProcessor) processor).setRSCompatible(true);
-        }
+    private void testProcessor(Processor processor,
+                               Consumer testBody) {
         CountingSubscriber subscriber = new CountingSubscriber();
-        IntSequencePublisher intSequencePublisher = new IntSequencePublisher();
-        intSequencePublisher.subscribe(HybridProcessor.from(processor));
-        processor.subscribe(HybridSubscriber.from(subscriber));
+        ReactiveStreams.generate(() -> 4)
+                .via(processor)
+                .to(subscriber)
+                .run();
         testBody.accept(subscriber);
-        assertEquals(expectedSum, subscriber.getSum().get());
     }
 }
\ No newline at end of file

From 68882266af68a683603e5fb90fa5585a574af7c6 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 9 Dec 2019 09:05:51 +0100
Subject: [PATCH 42/66] Passing 1136 failing 104/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../BackPressureOverflowException.java        |  24 +++
 .../common/reactive/BaseProcessor.java        |  12 +-
 .../common/reactive/LimitProcessor.java       |  19 +--
 .../reactive/RSCompatibleProcessor.java       |  62 +++++++-
 .../common/reactive/SkipProcessor.java        |  14 +-
 .../common/reactive/TakeWhileProcessor.java   |   2 +-
 .../io/helidon/common/reactive/MultiTest.java |   5 +-
 .../reactive/CumulativeProcessor.java         |   7 +
 .../reactive/FlatMapProcessor.java            |  35 +++--
 .../microprofile/reactive/OfPublisher.java    |   1 +
 .../reactive/hybrid/HybridSubscriber.java     |  44 +++++-
 .../reactive/AbstractProcessorTest.java       | 144 ++++++++++++++++++
 .../reactive/CountingSubscriber.java          |  37 ++++-
 .../reactive/DropWhileProcessorTest.java      |  28 ++++
 .../microrofile/reactive/EngineTest.java      |  27 ++--
 .../reactive/FilterProcessorTest.java         |  28 ++++
 .../FlatMapCompletionStageProcessorTest.java  |  30 ++++
 .../FlatMapIterableProcessorTest.java         |  30 ++++
 .../FlatMapPublisherProcessorTest.java        |  28 ++++
 .../reactive/LimitProcessorTest.java          |  43 ++++++
 .../reactive/MapProcessorTest.java            |  30 ++++
 .../microrofile/reactive/MockPublisher.java   |  56 +++++++
 .../reactive/PeekProcessorTest.java           |  30 ++++
 .../reactive/SkipProcessorTest.java           |  47 ++++++
 .../reactive/TakeWhileProcessorTest.java      |  28 ++++
 .../reactive/TappedProcessorTest.java         |  33 ++++
 26 files changed, 761 insertions(+), 83 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
new file mode 100644
index 00000000000..3a3154384f8
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+public class BackPressureOverflowException extends Exception {
+    public BackPressureOverflowException(int limit) {
+        super(String.format("Buffer limit %d exceeded.", limit));
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index c37dc3d1f2e..8a7c3c19464 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -15,12 +15,10 @@
  */
 package io.helidon.common.reactive;
 
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Flow.Processor;
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
-import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -51,7 +49,7 @@ public BaseProcessor() {
 
     @Override
     public void request(long n) {
-        requested.increment(n, ex -> onError(ex));
+        requested.increment(n, this::onError);
         tryRequest(subscription);
         if (done) {
             tryComplete();
@@ -98,7 +96,7 @@ public void onError(Throwable ex) {
     }
 
     @Override
-    public final void onComplete() {
+    public void onComplete() {
         done = true;
         tryComplete();
     }
@@ -158,10 +156,14 @@ protected void submit(U item) {
                 onError(ex);
             }
         } else {
-            onError(new IllegalStateException("Not enough request to submit item"));
+            notEnoughRequest(item);
         }
     }
 
+    protected void notEnoughRequest(U item) {
+        onError(new IllegalStateException("Not enough request to submit item"));
+    }
+
     /**
      * Hook for {@link Subscriber#onNext(java.lang.Object)}.
      *
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index 8a443a5d8b6..74fdb5f4161 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -45,17 +45,6 @@ public void subscribe(Flow.Subscriber s) {
         }
     }
 
-    @Override
-    protected void tryRequest(Flow.Subscription s) {
-        if (s != null && !getSubscriber().isClosed()) {
-            long n = getRequestedCounter().get();
-            if (n > 0) {
-                //Request one by one with limit
-                s.request(1);
-            }
-        }
-    }
-
     @Override
     public void onError(Throwable ex) {
         if (0 < this.counter.get()) {
@@ -68,14 +57,8 @@ protected void hookOnNext(T item) {
         long actCounter = this.counter.getAndDecrement();
         if (0 < actCounter) {
             submit(item);
-            if (1 < actCounter) {
-                // Don't request after last run
-                getRequestedCounter().increment(1, this::onError);
-                tryRequest(getSubscription());
-            } else {
-                tryComplete();
-            }
         } else {
+            getSubscription().cancel();
             tryComplete();
         }
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index 9af8b680686..215fdd8009d 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -17,12 +17,18 @@
 
 package io.helidon.common.reactive;
 
+import java.lang.ref.WeakReference;
 import java.util.Objects;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 
 public class RSCompatibleProcessor extends BaseProcessor {
 
+    private static final int BACK_PRESSURE_BUFFER_SIZE = 1024;
+
     private boolean rsCompatible = false;
     private ReferencedSubscriber referencedSubscriber;
+    private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
 
     public void setRSCompatible(boolean rsCompatible) {
         this.rsCompatible = rsCompatible;
@@ -41,6 +47,19 @@ public void request(long n) {
         super.request(n);
     }
 
+    @Override
+    protected void tryRequest(Flow.Subscription subscription) {
+        if (rsCompatible && !getSubscriber().isClosed() && !buffer.isEmpty()) {
+            try {
+                submit(buffer.take());
+            } catch (InterruptedException e) {
+                onError(e);
+            }
+        } else {
+            super.tryRequest(subscription);
+        }
+    }
+
     @Override
     public void subscribe(Flow.Subscriber s) {
         referencedSubscriber = ReferencedSubscriber.create(s);
@@ -83,6 +102,29 @@ public void onSubscribe(Flow.Subscription s) {
         super.onSubscribe(s);
     }
 
+    @Override
+    protected void notEnoughRequest(U item) {
+        if (rsCompatible) {
+            if (!buffer.offer(item)) {
+                onError(new BackPressureOverflowException(BACK_PRESSURE_BUFFER_SIZE));
+            }
+        } else {
+            super.notEnoughRequest(item);
+        }
+    }
+
+    @Override
+    protected void submit(U item) {
+        super.submit(item);
+    }
+
+    @Override
+    public void onComplete() {
+        if (buffer.isEmpty()) {
+            super.onComplete();
+        }
+    }
+
     @Override
     public void onError(Throwable ex) {
         if (rsCompatible) {
@@ -92,11 +134,13 @@ public void onError(Throwable ex) {
         super.onError(ex);
     }
 
-    private static class ReferencedSubscriber implements Flow.Subscriber {
+    public static class ReferencedSubscriber implements Flow.Subscriber {
 
         private Flow.Subscriber subscriber;
+        private WeakReference> subscriberWeakReference;
 
         private ReferencedSubscriber(Flow.Subscriber subscriber) {
+            //Objects.requireNonNull(subscriber);
             this.subscriber = subscriber;
         }
 
@@ -105,9 +149,19 @@ public static  ReferencedSubscriber create(Flow.Subscriber subscriber)
         }
 
         public void releaseReference() {
+            this.subscriberWeakReference = new WeakReference<>(this.subscriber);
             this.subscriber = null;
         }
 
+        private Flow.Subscriber getSubscriberReference() {
+            if (Objects.nonNull(subscriber)) {
+                return subscriber;
+            } else if (Objects.nonNull(subscriberWeakReference)) {
+                return subscriberWeakReference.get();
+            }
+            return null;
+        }
+
         @Override
         public void onSubscribe(Flow.Subscription subscription) {
             subscriber.onSubscribe(subscription);
@@ -115,17 +169,17 @@ public void onSubscribe(Flow.Subscription subscription) {
 
         @Override
         public void onNext(T item) {
-            subscriber.onNext(item);
+            getSubscriberReference().onNext(item);
         }
 
         @Override
         public void onError(Throwable throwable) {
-            subscriber.onError(throwable);
+            getSubscriberReference().onError(throwable);
         }
 
         @Override
         public void onComplete() {
-            subscriber.onComplete();
+            getSubscriberReference().onComplete();
         }
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
index a3de306dbd5..a025377dd77 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
@@ -32,17 +32,6 @@ public SkipProcessor(Long skip) {
         counter = new AtomicLong(skip);
     }
 
-    @Override
-    protected void tryRequest(Flow.Subscription s) {
-        if (s != null && !getSubscriber().isClosed()) {
-            long n = getRequestedCounter().get();
-            if (n > 0) {
-                //Request one by one with skip
-                s.request(1);
-            }
-        }
-    }
-
     @Override
     protected void hookOnNext(T item) {
         long actCounter = this.counter.getAndDecrement();
@@ -50,8 +39,7 @@ protected void hookOnNext(T item) {
             submit(item);
         } else {
             getRequestedCounter().tryDecrement();
+            request(1);
         }
-        getRequestedCounter().increment(1, this::onError);
-        tryRequest(getSubscription());
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 2f5786f1a9e..05307f072ed 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
+public class    TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
     private Predicate predicate;
 
     public TakeWhileProcessor(Predicate predicate) {
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index 5f15d3880cd..9ad139f9156 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -296,19 +296,18 @@ void testLimit() {
         AtomicInteger multiSum2 = new AtomicInteger();
 
         Multi.just(TEST_DATA)
-                .peek(multiSum1::addAndGet)
                 .limit(TEST_LIMIT)
+                .peek(multiSum1::addAndGet)
                 .forEach(multiSum2::addAndGet);
 
         AtomicInteger streamSum1 = new AtomicInteger();
         AtomicInteger streamSum2 = new AtomicInteger();
 
         TEST_DATA.stream()
-                .peek(streamSum1::addAndGet)
                 .limit(TEST_LIMIT)
+                .peek(streamSum1::addAndGet)
                 .forEach(streamSum2::addAndGet);
 
-        assertThat(multiSum1.get(), is(equalTo(EXPECTED_SUM)));
         assertThat(multiSum2.get(), is(equalTo(EXPECTED_SUM)));
         assertThat(streamSum1.get(), is(equalTo(EXPECTED_SUM)));
         assertThat(streamSum2.get(), is(equalTo(EXPECTED_SUM)));
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index 3def2b15db9..8cf2a76df25 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -33,6 +33,7 @@
  */
 public class CumulativeProcessor implements Processor {
     private LinkedList> processorList = new LinkedList<>();
+    private Subscription subscription;
 
     /**
      * Create {@link org.reactivestreams.Processor} wrapping ordered list of {@link io.helidon.common.reactive.Flow.Processor}s.
@@ -51,9 +52,15 @@ public void subscribe(Subscriber s) {
         processorList.getLast().subscribe(s);
     }
 
+
     @Override
     public void onSubscribe(Subscription subscription) {
         Objects.requireNonNull(subscription);
+        if (Objects.nonNull(this.subscription)) {
+            subscription.cancel();
+            return;
+        }
+        this.subscription = subscription;
         // This is the time for connecting all processors
         Processor lastProcessor = null;
         for (Processor processor : processorList) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index d920a7ac1e3..af27b69a855 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -24,6 +24,8 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
 
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.reactivestreams.Processor;
@@ -39,7 +41,7 @@ public class FlatMapProcessor implements Processor {
     private Function mapper;
 
     private final AtomicBoolean innerPublisherCompleted = new AtomicBoolean(true);
-    private Subscriber subscriber;
+    private HybridSubscriber subscriber;
     private Subscription subscription;
     private final AtomicLong requestCounter = new AtomicLong();
     private Subscription innerSubscription;
@@ -103,8 +105,10 @@ private class FlatMapSubscription implements Subscription {
         @Override
         public void request(long n) {
             requestCounter.addAndGet(n);
-            if (innerPublisherCompleted.getAndSet(false)) {
+            if (innerPublisherCompleted.getAndSet(false) || Objects.isNull(innerSubscription)) {
                 subscription.request(requestCounter.get());
+            } else {
+                innerSubscription.request(requestCounter.get());
             }
         }
 
@@ -113,13 +117,13 @@ public void cancel() {
             subscription.cancel();
             Optional.ofNullable(innerSubscription).ifPresent(Subscription::cancel);
             // https://github.com/reactive-streams/reactive-streams-jvm#3.13
-            subscriber = null;
+            subscriber.releaseReferences();
         }
     }
 
     @Override
     public void subscribe(Subscriber subscriber) {
-        this.subscriber = subscriber;
+        this.subscriber = HybridSubscriber.from(subscriber);
         if (Objects.nonNull(this.subscription)) {
             subscriber.onSubscribe(new FlatMapSubscription());
         }
@@ -153,8 +157,11 @@ public void onNext(Object o) {
     @Override
     public void onError(Throwable t) {
         this.error = Optional.of(t);
-        Optional.ofNullable(subscriber)
-                .ifPresent(s -> s.onError(this.error.get()));
+        if (Objects.nonNull(subscriber)) {
+            subscriber.onError(t);
+        } else {
+            throw new RuntimeException(t);
+        }
     }
 
     @Override
@@ -169,15 +176,20 @@ public void onSubscribe(Subscription innerSubscription) {
             Objects.requireNonNull(innerSubscription);
             innerPublisherCompleted.set(false);
             FlatMapProcessor.this.innerSubscription = innerSubscription;
-            innerSubscription.request(1L);
+            long requestCount = requestCounter.get();
+            if (requestCount > 0) {
+                innerSubscription.request(requestCount);
+            }
         }
 
         @Override
         public void onNext(Object o) {
             Objects.requireNonNull(o);
             FlatMapProcessor.this.subscriber.onNext(o);
-            requestCounter.decrementAndGet();
-            innerSubscription.request(1L);
+            long requestCount = requestCounter.decrementAndGet();
+            if (requestCount > 0) {
+                innerSubscription.request(requestCount);
+            }
         }
 
         @Override
@@ -190,7 +202,10 @@ public void onError(Throwable t) {
         @Override
         public void onComplete() {
             innerPublisherCompleted.set(true);
-            subscription.request(requestCounter.get());
+            long requestCount = requestCounter.get();
+            if (requestCount > 0) {
+                subscription.request(requestCount);
+            }
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index fc81962db13..d9b583d69dc 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -45,6 +45,7 @@ public void request(long n) {
                         subscriber.onNext(iterator.next());
                     } else {
                         subscriber.onComplete();
+                        break;
                     }
                 }
             }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index f4b023df0f3..7cef9dbcd18 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -17,8 +17,11 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
+import java.lang.ref.WeakReference;
 import java.security.InvalidParameterException;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
 
 import io.helidon.common.reactive.Flow;
 
@@ -36,12 +39,17 @@ public class HybridSubscriber implements Flow.Subscriber, Subscriber {
 
     private Flow.Subscriber flowSubscriber;
     private Subscriber reactiveSubscriber;
+    private WeakReference> reactiveSubscriberWeakRefecence;
+    private WeakReference> flowSubscriberWeakRefecence;
+    private Type type;
 
     private HybridSubscriber(Flow.Subscriber subscriber) {
+        this.type = Type.FLOW;
         this.flowSubscriber = subscriber;
     }
 
     private HybridSubscriber(Subscriber subscriber) {
+        this.type = Type.RS;
         this.reactiveSubscriber = subscriber;
     }
 
@@ -100,13 +108,9 @@ public void onSubscribe(Subscription subscription) {
 
     @Override
     public void onNext(T item) {
-        if (flowSubscriber != null) {
-            flowSubscriber.onNext(item);
-        } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onNext(item);
-        } else {
-            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
-        }
+        doWithAvailableSubscriber(
+                rsSubscriber -> rsSubscriber.onNext(item),
+                flowSubscriber -> flowSubscriber.onNext(item));
     }
 
     @Override
@@ -129,9 +133,33 @@ public void onComplete() {
         }
     }
 
-    public void releaseReferences(){
+    private void doWithAvailableSubscriber(Consumer> rsConsumer, Consumer> flowConsumer) {
+        if (type == Type.FLOW) {
+            if (Objects.nonNull(flowSubscriber)) {
+                flowConsumer.accept(flowSubscriber);
+            } else {
+                Optional.ofNullable(flowSubscriberWeakRefecence.get())
+                        .ifPresent(flowConsumer::accept);
+            }
+        } else if (type == Type.RS) {
+            if (Objects.nonNull(reactiveSubscriber)) {
+                rsConsumer.accept(reactiveSubscriber);
+            } else {
+                Optional.ofNullable(reactiveSubscriberWeakRefecence.get())
+                        .ifPresent(rsConsumer::accept);
+            }
+        }
+    }
+
+    public void releaseReferences() {
+        flowSubscriberWeakRefecence = new WeakReference<>(flowSubscriber);
+        reactiveSubscriberWeakRefecence = new WeakReference<>(reactiveSubscriber);
         flowSubscriber = null;
         reactiveSubscriber = null;
     }
 
+    private enum Type {
+        RS, FLOW
+    }
+
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
new file mode 100644
index 00000000000..04882518fb9
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscription;
+
+public abstract class AbstractProcessorTest {
+
+    protected abstract Processor getProcessor();
+
+    /**
+     * https://github.com/reactive-streams/reactive-streams-jvm#1.1
+     */
+    @Test
+    void requestCount() {
+        MockPublisher p = new MockPublisher();
+        testProcessor(ReactiveStreams.fromPublisher(p).via(getProcessor()).buildRs(), s -> {
+            s.expectRequestCount(0);
+            s.request(1);
+            p.sendNext(4);
+            s.expectRequestCount(1);
+            s.request(1);
+            s.request(2);
+            p.sendNext(5);
+            p.sendNext(6);
+            p.sendNext(7);
+            s.expectRequestCount(4);
+            s.cancel();
+        });
+    }
+
+    /**
+     * https://github.com/reactive-streams/reactive-streams-jvm#2.8
+     */
+    @Test
+    void nextAfterCancel() {
+        MockPublisher p = new MockPublisher();
+        testProcessor(ReactiveStreams.fromPublisher(p).via(getProcessor()).buildRs(), s -> {
+            s.request(2);
+            s.cancel();
+            p.sendNext(2);
+            p.sendNext(4);
+            s.expectSum(6);
+        });
+    }
+
+    /**
+     * https://github.com/reactive-streams/reactive-streams-jvm#2.5
+     */
+    @Test
+    void cancel2ndSubscription() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        MockPublisher p = new MockPublisher();
+        Processor processor = getProcessor();
+        testProcessor(ReactiveStreams.fromPublisher(p).via(processor).buildRs(), s -> {
+            s.request(2);
+        });
+
+        processor.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+
+            }
+
+            @Override
+            public void cancel() {
+                cancelled.complete(null);
+            }
+        });
+
+        cancelled.get(1, TimeUnit.SECONDS);
+    }
+
+
+    @Test
+    void onCompletePropagation() {
+        testProcessor(ReactiveStreams.of(1, 2, 3).via(getProcessor()).buildRs(), s -> {
+            s.request(1);
+            s.expectRequestCount(1);
+            s.request(2);
+            s.expectRequestCount(3);
+            s.expectOnComplete();
+        });
+    }
+
+    @Test
+    void requestCountProcessorTest() {
+        testProcessor(ReactiveStreams.generate(() -> 4).via(getProcessor()).buildRs(), s -> {
+            s.request(15);
+            s.expectRequestCount(15);
+            s.request(2);
+            s.expectRequestCount(17);
+            s.expectSum(17 * 4);
+        });
+    }
+
+    @Test
+    void finiteOnCompleteTest() throws InterruptedException, ExecutionException, TimeoutException {
+        finiteOnCompleteTest(getProcessor());
+    }
+
+    private  void finiteOnCompleteTest(Processor processor)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture completed = new CompletableFuture<>();
+        ReactiveStreams.of(1, 2, 3)
+                .via(processor)
+                .onComplete(() -> completed.complete(null))
+                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        completed.get(1, TimeUnit.SECONDS);
+    }
+
+    protected void testProcessor(Publisher publisher,
+                               Consumer testBody) {
+        CountingSubscriber subscriber = new CountingSubscriber();
+        publisher.subscribe(subscriber);
+        testBody.accept(subscriber);
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
index 4390460c324..595d0116931 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
@@ -18,20 +18,28 @@
 package io.helidon.microrofile.reactive;
 
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import io.helidon.microprofile.reactive.ExceptionUtils;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
 public class CountingSubscriber implements Subscriber {
     private Subscription subscription;
-    public AtomicInteger sum = new AtomicInteger(0);
+    public AtomicLong sum = new AtomicLong(0);
     public AtomicInteger requestCount = new AtomicInteger(0);
-    public CompletableFuture completed = new CompletableFuture<>();
+    public CompletableFuture completed = new CompletableFuture<>();
+    private AtomicBoolean expectError = new AtomicBoolean(false);
 
     @Override
     public void onSubscribe(Subscription subscription) {
@@ -40,14 +48,15 @@ public void onSubscribe(Subscription subscription) {
 
     @Override
     public void onNext(Integer item) {
-        System.out.println("Received: " + item);
         requestCount.incrementAndGet();
         sum.addAndGet((int) item);
     }
 
     @Override
     public void onError(Throwable throwable) {
-        ExceptionUtils.throwUncheckedException(throwable);
+        if(!expectError.get()){
+            ExceptionUtils.throwUncheckedException(throwable);
+        }
     }
 
     @Override
@@ -56,7 +65,6 @@ public void onComplete() {
     }
 
     public void request(long n) {
-        System.out.println("Requested: " + n);
         subscription.request(n);
     }
 
@@ -64,15 +72,28 @@ public void cancel() {
         subscription.cancel();
     }
 
-    public AtomicInteger getSum() {
+    public AtomicLong getSum() {
         return sum;
     }
 
     public void expectRequestCount(int n) {
-        assertEquals(n, requestCount.get());
+        assertEquals(n, requestCount.get(), String.format("Expected %d requests but only %d received.", n, requestCount.get()));
     }
 
-    public void expectSum(int n) {
+    public void expectSum(long n) {
         assertEquals(n, sum.get());
     }
+
+    public void expectError(){
+        expectError.set(true);
+    }
+
+    public void expectOnComplete() {
+        try {
+            request(1);
+            completed.get(1, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            fail(e);
+        }
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
new file mode 100644
index 00000000000..aa180750f5b
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class DropWhileProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().dropWhile(integer -> false).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 93d5c7863b2..d72fb623f57 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -35,6 +35,7 @@
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import java.util.stream.LongStream;
 
 import io.helidon.common.reactive.DropWhileProcessor;
 import io.helidon.common.reactive.FilterProcessor;
@@ -106,22 +107,16 @@ void publisherWithMapAndPeekAndFilter() {
     void fromTo() throws ExecutionException, InterruptedException, TimeoutException {
         AtomicInteger sum = new AtomicInteger();
         IntSequencePublisher publisher = new IntSequencePublisher();
-        StringBuilder beforeFilter = new StringBuilder();
-        StringBuilder afterFilter = new StringBuilder();
         ReactiveStreams
                 .fromPublisher(publisher)
                 .map(String::valueOf)
                 .map(i -> i + "-")
-                .peek(beforeFilter::append)
                 .map(s -> s.replaceAll("-", ""))
                 .map(Integer::parseInt)
                 .filter(i -> i % 2 == 0)
-                .peek(afterFilter::append)
                 .limit(5L)
                 .to(ReactiveStreams.fromSubscriber(new ConsumableSubscriber<>(sum::addAndGet, 10)))
                 .run();
-        assertEquals("1-2-3-4-5-6-7-8-9-10-", beforeFilter.toString());
-        assertEquals("246810", afterFilter.toString());
         assertEquals(2 + 4 + 6 + 8 + 10, sum.get());
     }
 
@@ -395,6 +390,7 @@ void filter() throws InterruptedException, ExecutionException, TimeoutException
     }
 
     @Test
+    @Disabled //TODO: Is this valid scenario?
     void publisherToSubscriber() throws InterruptedException, ExecutionException, TimeoutException {
         CompletionSubscriber> subscriber = ReactiveStreams.builder()
                 .limit(5L)
@@ -883,18 +879,23 @@ void finiteStream() throws InterruptedException, ExecutionException, TimeoutExce
 
     @Test
     void limitProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
-//        testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
-//            s.request(Long.MAX_VALUE / 2);
-//            s.request(Long.MAX_VALUE / 2);
-//            s.request(1);
-//
-//        });
+        testProcessor(ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs(), s -> {
+            s.request(10);
+            s.expectRequestCount(10);
+            s.request(2);
+            s.expectRequestCount(12);
+            s.expectSum(12 * 4);
+        });
+    }
+
+    @Test
+    void filterProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
         testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
             s.request(15);
             s.expectRequestCount(15);
             s.request(2);
             s.expectRequestCount(17);
-            s.expectSum(68);
+            s.expectSum(17 * 4);
         });
     }
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
new file mode 100644
index 00000000000..ae94cf60358
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class FilterProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().filter(integer -> true).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
new file mode 100644
index 00000000000..465d10c9845
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class FlatMapCompletionStageProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMapCompletionStage(CompletableFuture::completedFuture).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
new file mode 100644
index 00000000000..0057cb891c0
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.Collections;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class FlatMapIterableProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMapIterable(Collections::singleton).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
new file mode 100644
index 00000000000..e88c84d9d36
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class FlatMapPublisherProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMap(ReactiveStreams::of).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
new file mode 100644
index 00000000000..2d2896faf09
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+
+public class LimitProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs();
+    }
+
+    @Test
+    void ignoreErrorsAfterDone() {
+        MockPublisher p = new MockPublisher();
+        testProcessor(ReactiveStreams.fromPublisher(p).limit(2).buildRs(), s -> {
+            s.request(4);
+            p.sendNext(2);
+            p.sendNext(4);
+            s.expectSum(6);
+            p.sendNext(8);
+            s.expectSum(6);
+            p.sendOnError(new TestThrowable());
+        });
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
new file mode 100644
index 00000000000..3fdbbdef9f0
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.function.Function;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class MapProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().map(Function.identity()).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
new file mode 100644
index 00000000000..844c4905c46
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class MockPublisher implements Publisher {
+    private Subscriber subscriber;
+
+    @Override
+    public void subscribe(Subscriber subscriber) {
+        this.subscriber = subscriber;
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+
+            }
+
+            @Override
+            public void cancel() {
+
+            }
+        });
+    }
+
+    public void sendNext(Integer value) {
+        subscriber.onNext(value);
+    }
+
+    public void sendOnComplete() {
+        subscriber.onComplete();
+    }
+
+    public void sendOnError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
new file mode 100644
index 00000000000..592781855c1
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.function.Function;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class PeekProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().peek(integer -> Function.identity()).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
new file mode 100644
index 00000000000..c1ccdbf51f4
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+
+public class SkipProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().skip(0).buildRs();
+    }
+
+    @Test
+    void skipItems() throws InterruptedException, ExecutionException, TimeoutException {
+        List result = ReactiveStreams.of(1, 2, 3, 4)
+                .peek(System.out::println)
+                .skip(2)
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(3, 4), result);
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
new file mode 100644
index 00000000000..979bc1c7267
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+
+public class TakeWhileProcessorTest extends AbstractProcessorTest {
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().takeWhile(integer -> true).buildRs();
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
new file mode 100644
index 00000000000..e2c912aa24f
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+
+import org.reactivestreams.Processor;
+
+public class TappedProcessorTest extends AbstractProcessorTest {
+    @Override
+    @SuppressWarnings("unchecked")
+    protected Processor getProcessor() {
+        Flow.Processor processor = TappedProcessor.create();
+        return HybridProcessor.from(processor);
+    }
+}

From 0ea5559f776408ca3eebde0c186ba9607f71ed09 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 9 Dec 2019 22:09:45 +0100
Subject: [PATCH 43/66] Passing 1160 failing 81/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessor.java        |  27 ++--
 .../common/reactive/DistinctProcessor.java    |  15 +--
 .../common/reactive/DropWhileProcessor.java   |  16 +--
 .../common/reactive/FilterProcessor.java      |  13 +-
 .../common/reactive/LimitProcessor.java       |   2 +-
 .../reactive/RSCompatibleProcessor.java       |  25 ++--
 .../common/reactive/TakeWhileProcessor.java   |  15 +--
 .../reactive/CoupledProcessor.java            |   2 +-
 .../reactive/FlatMapProcessor.java            |   2 -
 .../FromCompletionStagePublisher.java         |   2 +-
 .../microprofile/reactive/MapProcessor.java   |  17 +--
 .../microprofile/reactive/OfPublisher.java    |   5 +-
 .../reactive/OnErrorResumeProcessor.java      |  21 ++-
 .../reactive/AbstractProcessorTest.java       |  47 +++++--
 .../reactive/CountingSubscriber.java          |  22 ++--
 .../reactive/DropWhileProcessorTest.java      |  11 +-
 .../microrofile/reactive/EngineTest.java      |  62 +--------
 .../reactive/FilterProcessorTest.java         |  11 +-
 .../FlatMapCompletionStageProcessorTest.java  |  11 +-
 .../FlatMapIterableProcessorTest.java         |  11 +-
 .../FlatMapPublisherProcessorTest.java        |  11 +-
 .../reactive/LimitProcessorTest.java          |  11 +-
 .../reactive/MapProcessorTest.java            |  11 +-
 .../microrofile/reactive/MockPublisher.java   |   8 +-
 .../reactive/OnErrorResumeProcessorTest.java  | 124 ++++++++++++++++++
 .../reactive/PeekProcessorTest.java           |  11 +-
 .../reactive/SkipProcessorTest.java           |  13 +-
 .../reactive/TakeWhileProcessorTest.java      |  11 +-
 .../reactive/TappedProcessorTest.java         |  11 +-
 .../reactive/HelidonStreamEngineTckTest.java  |   2 +-
 30 files changed, 375 insertions(+), 175 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 8a7c3c19464..59d195257e8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -19,6 +19,7 @@
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -49,7 +50,7 @@ public BaseProcessor() {
 
     @Override
     public void request(long n) {
-        requested.increment(n, this::onError);
+        requested.increment(n, this::fail);
         tryRequest(subscription);
         if (done) {
             tryComplete();
@@ -62,7 +63,7 @@ public void cancel() {
         try {
             hookOnCancel(subscription);
         } catch (Throwable ex) {
-            onError(ex);
+            fail(ex);
         }
     }
 
@@ -82,10 +83,20 @@ public void onNext(T item) {
         try {
             hookOnNext(item);
         } catch (Throwable ex) {
-            onError(ex);
+            fail(ex);
         }
     }
 
+    /**
+     * Proxy caller of {@link BaseProcessor#onError(java.lang.Throwable)} to avoid
+     * https://github.com/reactive-streams/reactive-streams-jvm#2.3c .
+     *
+     * @param ex Exception to be reported downstream
+     */
+    protected void fail(Throwable ex) {
+        onError(ex);
+    }
+
     @Override
     public void onError(Throwable ex) {
         done = true;
@@ -118,8 +129,8 @@ public void subscribe(Subscriber s) {
      *
      * @return {@link io.helidon.common.reactive.Flow.Subscription}
      */
-    protected Subscription getSubscription() {
-        return subscription;
+    protected Optional getSubscription() {
+        return Optional.ofNullable(subscription);
     }
 
     /**
@@ -151,9 +162,9 @@ protected void submit(U item) {
                 subscriber.get().onNext(item);
             } catch (InterruptedException ex) {
                 Thread.currentThread().interrupt();
-                onError(ex);
+                fail(ex);
             } catch (Throwable ex) {
-                onError(ex);
+                fail(ex);
             }
         } else {
             notEnoughRequest(item);
@@ -214,7 +225,7 @@ public void onNext(U item) {
 
                 @Override
                 public void onError(Throwable ex) {
-                    BaseProcessor.this.onError(ex);
+                    BaseProcessor.this.fail(ex);
                 }
 
                 @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
index f2ad980cf34..2a33dcf5376 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
@@ -33,16 +33,11 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     protected void hookOnNext(T item) {
-        try {
-            if (!distinctSet.contains(item)) {
-                distinctSet.add(item);
-                submit(item);
-            } else {
-                tryRequest(getSubscription());
-            }
-        } catch (Throwable t) {
-            getSubscription().cancel();
-            onError(t);
+        if (!distinctSet.contains(item)) {
+            distinctSet.add(item);
+            submit(item);
+        } else {
+            tryRequest(getSubscription().get());
         }
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
index bb2d9a794b1..057e389459a 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
@@ -35,16 +35,12 @@ public DropWhileProcessor(Predicate predicate) {
 
     @Override
     protected void hookOnNext(T item) {
-        try {
-            if (foundNotMatching || !predicate.test(item)) {
-                foundNotMatching = true;
-                submit(item);
-            } else {
-                tryRequest(getSubscription());
-            }
-        } catch (Throwable t) {
-            getSubscription().cancel();
-            onError(t);
+        if (foundNotMatching || !predicate.test(item)) {
+            foundNotMatching = true;
+            submit(item);
+        } else {
+            tryRequest(getSubscription().get());
         }
+
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 17f52376b9f..760e0fb323b 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -39,15 +39,10 @@ public FilterProcessor(Predicate predicate) {
 
     @Override
     protected void hookOnNext(T item) {
-        try {
-            if (predicate.test(item)) {
-                submit(item);
-            } else {
-                tryRequest(getSubscription());
-            }
-        } catch (Throwable t) {
-            getSubscription().cancel();
-            onError(t);
+        if (predicate.test(item)) {
+            submit(item);
+        } else {
+            tryRequest(getSubscription().get());
         }
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index 74fdb5f4161..fad58f58cc5 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -58,7 +58,7 @@ protected void hookOnNext(T item) {
         if (0 < actCounter) {
             submit(item);
         } else {
-            getSubscription().cancel();
+            getSubscription().get().cancel();
             tryComplete();
         }
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index 215fdd8009d..5d3a1620095 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -19,6 +19,7 @@
 
 import java.lang.ref.WeakReference;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 
@@ -42,7 +43,7 @@ public boolean isRsCompatible() {
     public void request(long n) {
         if (rsCompatible && n <= 0) {
             // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-            onError(new IllegalArgumentException("non-positive subscription request"));
+            fail(new IllegalArgumentException("non-positive subscription request"));
         }
         super.request(n);
     }
@@ -53,7 +54,7 @@ protected void tryRequest(Flow.Subscription subscription) {
             try {
                 submit(buffer.take());
             } catch (InterruptedException e) {
-                onError(e);
+                fail(e);
             }
         } else {
             super.tryRequest(subscription);
@@ -69,7 +70,7 @@ public void subscribe(Flow.Subscriber s) {
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         if (rsCompatible) {
-            subscription.cancel();
+            Optional.ofNullable(subscription).ifPresent(Flow.Subscription::cancel);
             referencedSubscriber.releaseReference();
         }
     }
@@ -82,7 +83,7 @@ public void onNext(T item) {
             try {
                 hookOnNext(item);
             } catch (Throwable ex) {
-                onError(ex);
+                fail(ex);
             }
         } else {
             super.onNext(item);
@@ -95,9 +96,7 @@ public void onSubscribe(Flow.Subscription s) {
             // https://github.com/reactive-streams/reactive-streams-jvm#2.13
             Objects.requireNonNull(s);
             // https://github.com/reactive-streams/reactive-streams-jvm#2.5
-            if (Objects.nonNull(super.getSubscription())) {
-                s.cancel();
-            }
+            getSubscription().ifPresent(firstSubscription -> s.cancel());
         }
         super.onSubscribe(s);
     }
@@ -106,7 +105,7 @@ public void onSubscribe(Flow.Subscription s) {
     protected void notEnoughRequest(U item) {
         if (rsCompatible) {
             if (!buffer.offer(item)) {
-                onError(new BackPressureOverflowException(BACK_PRESSURE_BUFFER_SIZE));
+                fail(new BackPressureOverflowException(BACK_PRESSURE_BUFFER_SIZE));
             }
         } else {
             super.notEnoughRequest(item);
@@ -125,6 +124,16 @@ public void onComplete() {
         }
     }
 
+    @Override
+    public void fail(Throwable ex) {
+        ex.printStackTrace();//TODO: remove
+        if (rsCompatible) {
+            //Upstream cancel on error with fail method proxy to avoid spec rule 2.3
+            getSubscription().ifPresent(Flow.Subscription::cancel);
+        }
+        super.fail(ex);
+    }
+
     @Override
     public void onError(Throwable ex) {
         if (rsCompatible) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 05307f072ed..7a52dac81d0 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class    TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
+public class TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
     private Predicate predicate;
 
     public TakeWhileProcessor(Predicate predicate) {
@@ -28,15 +28,10 @@ public TakeWhileProcessor(Predicate predicate) {
 
     @Override
     protected void hookOnNext(T item) {
-        try {
-            if (predicate.test(item)) {
-                submit(item);
-            } else {
-                tryComplete();
-            }
-        } catch (Throwable t) {
-            getSubscription().cancel();
-            onError(t);
+        if (predicate.test(item)) {
+            submit(item);
+        } else {
+            tryComplete();
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index f14c8b97d0e..37f84579cd0 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -100,7 +100,7 @@ public void request(long n) {
             @Override
             public void cancel() {
                 upStreamSubscription.cancel();
-                downStreamsSubscription.cancel();
+                //downStreamsSubscription.cancel();//LIVELOCK!!!
                 downStreamSubscriber.onComplete();
             }
         });
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index af27b69a855..fd542233804 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -159,8 +159,6 @@ public void onError(Throwable t) {
         this.error = Optional.of(t);
         if (Objects.nonNull(subscriber)) {
             subscriber.onError(t);
-        } else {
-            throw new RuntimeException(t);
         }
     }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
index 5f0fde0dc02..15bf2748a81 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
@@ -60,7 +60,7 @@ public void cancel() {
     }
 
     private void emit(T item) {
-        if (!Objects.isNull(item)) {
+        if (Objects.nonNull(item)) {
             subscriber.onNext(item);
             subscriber.onComplete();
         } else {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
index 3b45e1fddd3..dc3162488d0 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
@@ -47,17 +47,12 @@ protected void hookOnCancel(Flow.Subscription subscription) {
 
     @Override
     protected void hookOnNext(T item) {
-        try {
-            U value = mapper.map(item);
-            if (value == null) {
-                getSubscription().cancel();
-                onError(new NullPointerException("Mapper returned a null value"));
-            } else {
-                submit(value);
-            }
-        } catch (Throwable e) {
-            getSubscription().cancel();
-            onError(e);
+        U value = mapper.map(item);
+        if (value == null) {
+            getSubscription().get().cancel();
+            onError(new NullPointerException("Mapper returned a null value"));
+        } else {
+            submit(value);
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index d9b583d69dc..a041b80640c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -18,6 +18,7 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.Iterator;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.helidon.common.reactive.Flow;
@@ -42,7 +43,9 @@ public void request(long n) {
                 }
                 for (long i = 0; i < n; i++) {
                     if (iterator.hasNext() && !cancelled.get()) {
-                        subscriber.onNext(iterator.next());
+                        Object next = iterator.next();
+                        Objects.requireNonNull(next);
+                        subscriber.onNext(next);
                     } else {
                         subscriber.onComplete();
                         break;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index bbc34228a3c..a865412bfe8 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -18,10 +18,12 @@
 package io.helidon.microprofile.reactive;
 
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Function;
 
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscription;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
 import org.reactivestreams.Publisher;
@@ -33,6 +35,8 @@ public class OnErrorResumeProcessor extends RSCompatibleProcessor {
 
     private Function supplier;
     private Function> publisherSupplier;
+    //TODO: sync access - onError can do async write
+    private Optional onErrorPublisherSubscription = Optional.empty();
 
     private OnErrorResumeProcessor() {
     }
@@ -50,6 +54,15 @@ static  OnErrorResumeProcessor resumeWith(Function suppl
         return processor;
     }
 
+    @Override
+    protected void tryRequest(Flow.Subscription subscription) {
+        if (onErrorPublisherSubscription.isPresent()) {
+            super.tryRequest(HybridSubscription.from(onErrorPublisherSubscription.get()));
+        } else {
+            super.tryRequest(subscription);
+        }
+    }
+
     @Override
     public void onError(Throwable ex) {
         Objects.requireNonNull(ex);
@@ -67,13 +80,15 @@ public void onError(Throwable ex) {
                     public void onSubscribe(Subscription subscription) {
                         Objects.requireNonNull(subscription);
                         this.subscription = subscription;
-                        subscription.request(getRequestedCounter().get());
+                        onErrorPublisherSubscription = Optional.of(subscription);
+                        if (getRequestedCounter().get() > 0) {
+                            subscription.request(getRequestedCounter().get());
+                        }
                     }
 
                     @Override
                     public void onNext(T t) {
                         submit(t);
-                        subscription.request(1);
                     }
 
                     @Override
@@ -85,6 +100,7 @@ public void onError(Throwable t) {
                     @Override
                     public void onComplete() {
                         OnErrorResumeProcessor.this.onComplete();
+                        onErrorPublisherSubscription = Optional.empty();
                     }
                 });
             }
@@ -100,5 +116,6 @@ private void superError(Throwable t) {
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         subscription.cancel();
+        onErrorPublisherSubscription.ifPresent(Subscription::cancel);
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index 04882518fb9..92a15f9bb81 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -17,13 +17,19 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -31,7 +37,9 @@
 
 public abstract class AbstractProcessorTest {
 
-    protected abstract Processor getProcessor();
+    protected abstract Processor getProcessor();
+
+    protected abstract Processor getFailedProcessor(RuntimeException t);
 
     /**
      * https://github.com/reactive-streams/reactive-streams-jvm#1.1
@@ -76,7 +84,7 @@ void nextAfterCancel() {
     void cancel2ndSubscription() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture cancelled = new CompletableFuture<>();
         MockPublisher p = new MockPublisher();
-        Processor processor = getProcessor();
+        Processor processor = getProcessor();
         testProcessor(ReactiveStreams.fromPublisher(p).via(processor).buildRs(), s -> {
             s.request(2);
         });
@@ -99,7 +107,7 @@ public void cancel() {
 
     @Test
     void onCompletePropagation() {
-        testProcessor(ReactiveStreams.of(1, 2, 3).via(getProcessor()).buildRs(), s -> {
+        testProcessor(ReactiveStreams.of(1L, 2L, 3L).via(getProcessor()).buildRs(), s -> {
             s.request(1);
             s.expectRequestCount(1);
             s.request(2);
@@ -110,7 +118,7 @@ void onCompletePropagation() {
 
     @Test
     void requestCountProcessorTest() {
-        testProcessor(ReactiveStreams.generate(() -> 4).via(getProcessor()).buildRs(), s -> {
+        testProcessor(ReactiveStreams.generate(() -> 4L).via(getProcessor()).buildRs(), s -> {
             s.request(15);
             s.expectRequestCount(15);
             s.request(2);
@@ -119,15 +127,38 @@ void requestCountProcessorTest() {
         });
     }
 
+    @Test
+    void longOverFlow() {
+        testProcessor(ReactiveStreams.generate(() -> 4L).via(getProcessor()).buildRs(), s -> {
+            s.cancelAfter(1_000_000L);
+            s.request(Long.MAX_VALUE - 1);
+            s.request(Long.MAX_VALUE - 1);
+        });
+    }
+
+    @Test
+    void cancelOnError() throws InterruptedException, ExecutionException, TimeoutException {
+        Processor failedProcessor = getFailedProcessor(new TestRuntimeException());
+        Assumptions.assumeTrue(Objects.nonNull(failedProcessor));
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.generate(() -> 4L)
+                .onTerminate(() -> cancelled.complete(null))
+                .via(failedProcessor)
+                .toList()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
+
     @Test
     void finiteOnCompleteTest() throws InterruptedException, ExecutionException, TimeoutException {
         finiteOnCompleteTest(getProcessor());
     }
 
-    private  void finiteOnCompleteTest(Processor processor)
+    private  void finiteOnCompleteTest(Processor processor)
             throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture completed = new CompletableFuture<>();
-        ReactiveStreams.of(1, 2, 3)
+        ReactiveStreams.of(1L, 2L, 3L)
                 .via(processor)
                 .onComplete(() -> completed.complete(null))
                 .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
@@ -135,8 +166,8 @@ private  void finiteOnCompleteTest(Processor processor)
         completed.get(1, TimeUnit.SECONDS);
     }
 
-    protected void testProcessor(Publisher publisher,
-                               Consumer testBody) {
+    protected void testProcessor(Publisher publisher,
+                                 Consumer testBody) {
         CountingSubscriber subscriber = new CountingSubscriber();
         publisher.subscribe(subscriber);
         testBody.accept(subscriber);
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
index 595d0116931..79c860fcddc 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
@@ -18,12 +18,10 @@
 package io.helidon.microrofile.reactive;
 
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 import io.helidon.microprofile.reactive.ExceptionUtils;
@@ -34,12 +32,13 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-public class CountingSubscriber implements Subscriber {
+public class CountingSubscriber implements Subscriber {
     private Subscription subscription;
     public AtomicLong sum = new AtomicLong(0);
-    public AtomicInteger requestCount = new AtomicInteger(0);
+    public AtomicLong requestCount = new AtomicLong(0);
     public CompletableFuture completed = new CompletableFuture<>();
     private AtomicBoolean expectError = new AtomicBoolean(false);
+    private AtomicLong cancelAfter = new AtomicLong(0);
 
     @Override
     public void onSubscribe(Subscription subscription) {
@@ -47,14 +46,17 @@ public void onSubscribe(Subscription subscription) {
     }
 
     @Override
-    public void onNext(Integer item) {
+    public void onNext(Long item) {
         requestCount.incrementAndGet();
-        sum.addAndGet((int) item);
+        sum.addAndGet(item);
+        if (cancelAfter.get() != 0 && requestCount.get() > cancelAfter.get()) {
+            cancel();
+        }
     }
 
     @Override
     public void onError(Throwable throwable) {
-        if(!expectError.get()){
+        if (!expectError.get()) {
             ExceptionUtils.throwUncheckedException(throwable);
         }
     }
@@ -72,6 +74,10 @@ public void cancel() {
         subscription.cancel();
     }
 
+    public void cancelAfter(long max) {
+        cancelAfter.set(max);
+    }
+
     public AtomicLong getSum() {
         return sum;
     }
@@ -84,7 +90,7 @@ public void expectSum(long n) {
         assertEquals(n, sum.get());
     }
 
-    public void expectError(){
+    public void expectError() {
         expectError.set(true);
     }
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
index aa180750f5b..c3128f9a611 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
@@ -22,7 +22,14 @@
 
 public class DropWhileProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().dropWhile(integer -> false).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().dropWhile(integer -> false).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().dropWhile(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index d72fb623f57..17796752903 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -35,7 +35,6 @@
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
-import java.util.stream.LongStream;
 
 import io.helidon.common.reactive.DropWhileProcessor;
 import io.helidon.common.reactive.FilterProcessor;
@@ -594,37 +593,6 @@ void generate() throws InterruptedException, ExecutionException, TimeoutExceptio
                         .get(1, TimeUnit.SECONDS));
     }
 
-    @Test
-    void onErrorResume() throws InterruptedException, ExecutionException, TimeoutException {
-        assertEquals(Collections.singletonList(4),
-                ReactiveStreams
-                        .generate(() -> 1)
-                        .limit(3L)
-                        .peek(i -> {
-                            throw new TestRuntimeException();
-                        })
-                        .onErrorResume(throwable -> 4)
-                        .toList()
-                        .run()
-                        .toCompletableFuture()
-                        .get(1, TimeUnit.SECONDS));
-    }
-
-    @Test
-    void onErrorResumeWith() throws InterruptedException, ExecutionException, TimeoutException {
-        assertEquals(Arrays.asList(1, 2, 3),
-                ReactiveStreams
-                        .generate(() -> 1)
-                        .limit(3L)
-                        .peek(i -> {
-                            throw new TestRuntimeException();
-                        })
-                        .onErrorResumeWith(throwable -> ReactiveStreams.of(1, 2, 3))
-                        .toList()
-                        .run()
-                        .toCompletableFuture()
-                        .get(1, TimeUnit.SECONDS));
-    }
 
     @Test
     void flatMapCancelPropagation() throws InterruptedException, ExecutionException, TimeoutException {
@@ -739,24 +707,6 @@ void coupledCompleteUpStreamOnCancel() throws InterruptedException, ExecutionExc
     }
 
 
-    @Test
-    void onErrorResume2() throws InterruptedException, ExecutionException, TimeoutException {
-        ReactiveStreams.failed(new TestThrowable())
-                .onErrorResumeWith(
-                        t -> ReactiveStreams.of(1, 2, 3)
-                )
-                .forEach(System.out::println).run().toCompletableFuture().get(1, TimeUnit.SECONDS);
-    }
-
-    @Test
-    void onErrorResume3() throws InterruptedException, ExecutionException, TimeoutException {
-        ReactiveStreams.failed(new TestThrowable())
-                .onErrorResumeWith(
-                        t -> ReactiveStreams.of(1, 2, 3)
-                )
-                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
-    }
-
     @Test
     void coupledStageReentrant() {
         ProcessorBuilder coupled = ReactiveStreams.coupled(ReactiveStreams.builder().ignore(), ReactiveStreams.of(1, 2, 3));
@@ -878,8 +828,8 @@ void finiteStream() throws InterruptedException, ExecutionException, TimeoutExce
     }
 
     @Test
-    void limitProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
-        testProcessor(ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs(), s -> {
+    void limitProcessorTest() {
+        testProcessor(ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs(), s -> {
             s.request(10);
             s.expectRequestCount(10);
             s.request(2);
@@ -889,8 +839,8 @@ void limitProcessorTest() throws InterruptedException, TimeoutException, Executi
     }
 
     @Test
-    void filterProcessorTest() throws InterruptedException, TimeoutException, ExecutionException {
-        testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
+    void filterProcessorTest() {
+        testProcessor(ReactiveStreams.builder().filter(o -> true).buildRs(), s -> {
             s.request(15);
             s.expectRequestCount(15);
             s.request(2);
@@ -910,10 +860,10 @@ private  void finiteOnCompleteTest(Flow.Processor proces
         completed.get(1, TimeUnit.SECONDS);
     }
 
-    private void testProcessor(Processor processor,
+    private void testProcessor(Processor processor,
                                Consumer testBody) {
         CountingSubscriber subscriber = new CountingSubscriber();
-        ReactiveStreams.generate(() -> 4)
+        ReactiveStreams.generate(() -> 4L)
                 .via(processor)
                 .to(subscriber)
                 .run();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
index ae94cf60358..05e68a4a951 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
@@ -22,7 +22,14 @@
 
 public class FilterProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().filter(integer -> true).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().filter(i -> true).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().filter(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
index 465d10c9845..14a19bdb91a 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
@@ -24,7 +24,14 @@
 
 public class FlatMapCompletionStageProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().flatMapCompletionStage(CompletableFuture::completedFuture).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMapCompletionStage(CompletableFuture::completedFuture).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().flatMapCompletionStage(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
index 0057cb891c0..478ed25dc18 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
@@ -24,7 +24,14 @@
 
 public class FlatMapIterableProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().flatMapIterable(Collections::singleton).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMapIterable(Collections::singleton).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().flatMapIterable(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
index e88c84d9d36..78a1a7ba159 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
@@ -22,7 +22,14 @@
 
 public class FlatMapPublisherProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().flatMap(ReactiveStreams::of).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().flatMap(ReactiveStreams::of).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().flatMap(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
index 2d2896faf09..b4116a8d692 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
@@ -23,14 +23,19 @@
 
 public class LimitProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return null;
     }
 
     @Test
     void ignoreErrorsAfterDone() {
         MockPublisher p = new MockPublisher();
-        testProcessor(ReactiveStreams.fromPublisher(p).limit(2).buildRs(), s -> {
+        testProcessor(ReactiveStreams.fromPublisher(p).limit(2).buildRs(), s -> {
             s.request(4);
             p.sendNext(2);
             p.sendNext(4);
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
index 3fdbbdef9f0..479dc8d184a 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MapProcessorTest.java
@@ -24,7 +24,14 @@
 
 public class MapProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().map(Function.identity()).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().map(Function.identity()).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().map(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
index 844c4905c46..63a95f82cec 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
@@ -21,11 +21,11 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-public class MockPublisher implements Publisher {
-    private Subscriber subscriber;
+public class MockPublisher implements Publisher {
+    private Subscriber subscriber;
 
     @Override
-    public void subscribe(Subscriber subscriber) {
+    public void subscribe(Subscriber subscriber) {
         this.subscriber = subscriber;
         subscriber.onSubscribe(new Subscription() {
             @Override
@@ -40,7 +40,7 @@ public void cancel() {
         });
     }
 
-    public void sendNext(Integer value) {
+    public void sendNext(long value) {
         subscriber.onNext(value);
     }
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
new file mode 100644
index 00000000000..c837c887710
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Publisher;
+
+public class OnErrorResumeProcessorTest {
+
+    @Test
+    void onErrorResume() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Collections.singletonList(4),
+                ReactiveStreams
+                        .generate(() -> 1)
+                        .limit(3L)
+                        .peek(i -> {
+                            throw new TestRuntimeException();
+                        })
+                        .onErrorResume(throwable -> 4)
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void onErrorResumeWith() throws InterruptedException, ExecutionException, TimeoutException {
+        assertEquals(Arrays.asList(1, 2, 3),
+                ReactiveStreams
+                        .generate(() -> 1)
+                        .limit(3L)
+                        .peek(i -> {
+                            throw new TestRuntimeException();
+                        })
+                        .onErrorResumeWith(throwable -> ReactiveStreams.of(1, 2, 3))
+                        .toList()
+                        .run()
+                        .toCompletableFuture()
+                        .get(1, TimeUnit.SECONDS));
+    }
+
+
+    @Test
+    void onErrorResume2() throws InterruptedException, ExecutionException, TimeoutException {
+        ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.of(1, 2, 3)
+                )
+                .forEach(System.out::println).run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void onErrorResume3() throws InterruptedException, ExecutionException, TimeoutException {
+        ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.of(1, 2, 3)
+                )
+                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void requestCount() {
+        Publisher pub = ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.fromIterable(() -> LongStream.rangeClosed(1, 3).boxed().iterator())
+                )
+                .buildRs();
+        CountingSubscriber sub = new CountingSubscriber();
+        ReactiveStreams.fromPublisher(pub).buildRs().subscribe(HybridSubscriber.from(sub));
+
+        sub.request(1);
+        sub.expectRequestCount(1);
+        sub.expectSum(1);
+        sub.request(2);
+        sub.expectSum(6);
+        sub.expectRequestCount(3);
+        sub.expectOnComplete();
+    }
+
+    @Test
+    void requestCount2() {
+        AtomicLong seq = new AtomicLong(0);
+        Publisher pub = ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.generate(seq::incrementAndGet)
+                )
+                .buildRs();
+        CountingSubscriber sub = new CountingSubscriber();
+        ReactiveStreams.fromPublisher(pub).buildRs().subscribe(HybridSubscriber.from(sub));
+
+        sub.cancelAfter(100_000L);
+        sub.request(Long.MAX_VALUE - 1);
+        sub.request(Long.MAX_VALUE - 1);
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
index 592781855c1..1e1127b58fb 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
@@ -24,7 +24,14 @@
 
 public class PeekProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().peek(integer -> Function.identity()).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().peek(i -> Function.identity()).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().peek(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
index c1ccdbf51f4..3f1b4b537bb 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
@@ -31,17 +31,22 @@
 
 public class SkipProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().skip(0).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().skip(0).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return null;
     }
 
     @Test
     void skipItems() throws InterruptedException, ExecutionException, TimeoutException {
-        List result = ReactiveStreams.of(1, 2, 3, 4)
+        List result = ReactiveStreams.of(1L, 2L, 3L, 4L)
                 .peek(System.out::println)
                 .skip(2)
                 .toList()
                 .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
-        assertEquals(Arrays.asList(3, 4), result);
+        assertEquals(Arrays.asList(3L, 4L), result);
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
index 979bc1c7267..f8465720b9e 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
@@ -22,7 +22,14 @@
 
 public class TakeWhileProcessorTest extends AbstractProcessorTest {
     @Override
-    protected Processor getProcessor() {
-        return ReactiveStreams.builder().takeWhile(integer -> true).buildRs();
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder().takeWhile(i -> true).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().takeWhile(i -> {
+            throw t;
+        }).buildRs();
     }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
index e2c912aa24f..7f802a52c67 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
@@ -26,8 +26,17 @@
 public class TappedProcessorTest extends AbstractProcessorTest {
     @Override
     @SuppressWarnings("unchecked")
-    protected Processor getProcessor() {
+    protected Processor getProcessor() {
         Flow.Processor processor = TappedProcessor.create();
         return HybridProcessor.from(processor);
     }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected Processor getFailedProcessor(RuntimeException t) {
+        Flow.Processor processor = TappedProcessor.create().onNext(o -> {
+            throw t;
+        });
+        return HybridProcessor.from(processor);
+    }
 }
diff --git a/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
index a5a9537b5da..520d01fabb3 100644
--- a/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
+++ b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
@@ -23,7 +23,7 @@
 public class HelidonStreamEngineTckTest extends ReactiveStreamsTck {
 
     public HelidonStreamEngineTckTest() {
-        super(new TestEnvironment());
+        super(new TestEnvironment(200,200,false));
     }
 
     @Override

From c6b82874cbd843df5b6cfe1597ead7ca452c340e Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 10 Dec 2019 11:29:10 +0100
Subject: [PATCH 44/66] Passing 1187 failing 54/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../common/reactive/LimitProcessor.java       |  4 +-
 .../reactive/RSCompatibleProcessor.java       |  1 -
 .../common/reactive/TakeWhileProcessor.java   |  1 +
 .../reactive/CollectSubscriber.java           |  2 +-
 .../reactive/FailedPublisher.java             |  2 +-
 .../reactive/OnErrorResumeProcessor.java      | 14 +++++
 .../microrofile/reactive/EngineTest.java      | 17 ++++++
 .../reactive/LimitProcessorTest.java          | 23 ++++++++
 .../reactive/OnErrorResumeProcessorTest.java  | 52 ++++++++++++++++++-
 .../reactive/TakeWhileProcessorTest.java      | 15 ++++++
 10 files changed, 125 insertions(+), 6 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index fad58f58cc5..b06173be181 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -49,6 +49,8 @@ public void subscribe(Flow.Subscriber s) {
     public void onError(Throwable ex) {
         if (0 < this.counter.get()) {
             super.onError(ex);
+        }else {
+            tryComplete();
         }
     }
 
@@ -58,7 +60,7 @@ protected void hookOnNext(T item) {
         if (0 < actCounter) {
             submit(item);
         } else {
-            getSubscription().get().cancel();
+            getSubscription().ifPresent(Flow.Subscription::cancel);
             tryComplete();
         }
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index 5d3a1620095..7b03e51c101 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -126,7 +126,6 @@ public void onComplete() {
 
     @Override
     public void fail(Throwable ex) {
-        ex.printStackTrace();//TODO: remove
         if (rsCompatible) {
             //Upstream cancel on error with fail method proxy to avoid spec rule 2.3
             getSubscription().ifPresent(Flow.Subscription::cancel);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 7a52dac81d0..84b7f1e4aab 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -31,6 +31,7 @@ protected void hookOnNext(T item) {
         if (predicate.test(item)) {
             submit(item);
         } else {
+            getSubscription().ifPresent(Flow.Subscription::cancel);
             tryComplete();
         }
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index 33b625b9b6f..da129acf2f1 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -140,7 +140,7 @@ public void onComplete() {
                     onError(t);
                 }
                 if (Objects.nonNull(subscription)) {
-                    subscription.cancel();
+                    //subscription.cancel();
                 }
             }
         };
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
index 2c0ce6869c2..d615b1a2e91 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
@@ -32,7 +32,7 @@ public void subscribe(Flow.Subscriber subscriber) {
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
-
+                subscriber.onError(throwable);
             }
 
             @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index a865412bfe8..c97ffa78e42 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -19,6 +19,7 @@
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
 import io.helidon.common.reactive.Flow;
@@ -33,6 +34,7 @@
 public class OnErrorResumeProcessor extends RSCompatibleProcessor {
 
 
+    private AtomicBoolean completed = new AtomicBoolean(false);
     private Function supplier;
     private Function> publisherSupplier;
     //TODO: sync access - onError can do async write
@@ -56,6 +58,10 @@ static  OnErrorResumeProcessor resumeWith(Function suppl
 
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
+        if (completed.get()) {
+            tryComplete();
+        }
+
         if (onErrorPublisherSubscription.isPresent()) {
             super.tryRequest(HybridSubscription.from(onErrorPublisherSubscription.get()));
         } else {
@@ -63,12 +69,18 @@ protected void tryRequest(Flow.Subscription subscription) {
         }
     }
 
+    @Override
+    protected void hookOnNext(T item) {
+        super.submit(item);
+    }
+
     @Override
     public void onError(Throwable ex) {
         Objects.requireNonNull(ex);
         try {
             if (Objects.nonNull(supplier)) {
 
+                completed.set(true);
                 submit(supplier.apply(ex));
                 tryComplete();
 
@@ -105,6 +117,8 @@ public void onComplete() {
                 });
             }
         } catch (Throwable t) {
+            onErrorPublisherSubscription.ifPresent(Subscription::cancel);
+            getSubscription().ifPresent(Flow.Subscription::cancel);
             superError(t);
         }
     }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 17796752903..d454241c720 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -35,6 +35,7 @@
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import java.util.stream.LongStream;
 
 import io.helidon.common.reactive.DropWhileProcessor;
 import io.helidon.common.reactive.FilterProcessor;
@@ -869,4 +870,20 @@ private void testProcessor(Processor processor,
                 .run();
         testBody.accept(subscriber);
     }
+
+    @Test
+    void name() {
+        Publisher pub = ReactiveStreams.failed(new Exception("BOOM"))
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.fromIterable(() -> LongStream.rangeClosed(1, 5).boxed().iterator())
+                )
+                .buildRs();
+
+        CountingSubscriber sub = new CountingSubscriber();
+
+        pub.subscribe(sub);
+
+        sub.request(1);
+        sub.expectRequestCount(1);
+    }
 }
\ No newline at end of file
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
index b4116a8d692..840eb6081dd 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
@@ -17,6 +17,15 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
@@ -45,4 +54,18 @@ void ignoreErrorsAfterDone() {
             p.sendOnError(new TestThrowable());
         });
     }
+
+    @Test
+    void ignoreErrorsAfterDone2() throws InterruptedException, ExecutionException, TimeoutException {
+        AtomicLong seq = new AtomicLong(0);
+        List result = ReactiveStreams.generate(seq::incrementAndGet).flatMap((i) -> {
+            return i == 4 ? ReactiveStreams.failed(new RuntimeException("failed")) : ReactiveStreams.of(i);
+        })
+                .limit(3L)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+        assertEquals(Arrays.asList(1L, 2L, 3L), result);
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
index c837c887710..8310c32b44f 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
@@ -19,11 +19,12 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.stream.IntStream;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.LongStream;
 
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
@@ -31,10 +32,12 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 
-public class OnErrorResumeProcessorTest {
+public class OnErrorResumeProcessorTest extends AbstractProcessorTest {
 
     @Test
     void onErrorResume() throws InterruptedException, ExecutionException, TimeoutException {
@@ -87,6 +90,22 @@ void onErrorResume3() throws InterruptedException, ExecutionException, TimeoutEx
                 .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
     }
 
+    @Override
+    protected Processor getProcessor() {
+        return ReactiveStreams.builder()
+                .onErrorResumeWith(throwable -> ReactiveStreams.of(1L, 2L))
+                .buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder()
+                .onErrorResumeWith(throwable -> {
+                    throw new TestRuntimeException();
+                })
+                .buildRs();
+    }
+
     @Test
     void requestCount() {
         Publisher pub = ReactiveStreams.failed(new TestThrowable())
@@ -121,4 +140,33 @@ void requestCount2() {
         sub.request(Long.MAX_VALUE - 1);
         sub.request(Long.MAX_VALUE - 1);
     }
+
+    @Test
+    void name() throws InterruptedException, ExecutionException, TimeoutException {
+        AtomicReference exception = new AtomicReference<>();
+        List result = ReactiveStreams.failed(new TestRuntimeException())
+                .onErrorResume(err -> {
+                    exception.set(err);
+                    return "foo";
+                })
+                .toList()
+                .run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+        assertEquals(Collections.singletonList("foo"), result);
+        assertEquals(TestRuntimeException.TEST_MSG, exception.get().getMessage());
+    }
+
+    @Test
+    void requestFinite() {
+        Publisher pub = ReactiveStreams.failed(new TestThrowable())
+                .onErrorResumeWith(
+                        t -> ReactiveStreams.fromIterable(() -> LongStream.rangeClosed(1, 4).boxed().iterator())
+                )
+                .buildRs();
+        CountingSubscriber sub = new CountingSubscriber();
+        ReactiveStreams.fromPublisher(pub).buildRs().subscribe(HybridSubscriber.from(sub));
+
+        sub.request(1);
+        sub.expectRequestCount(1);
+        sub.expectSum(1);
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
index f8465720b9e..cde07ad7381 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
@@ -17,7 +17,13 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 
 public class TakeWhileProcessorTest extends AbstractProcessorTest {
@@ -32,4 +38,13 @@ protected Processor getFailedProcessor(RuntimeException t) {
             throw t;
         }).buildRs();
     }
+
+    @Test
+    void cancelWhenDone() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        ReactiveStreams.generate(() -> 4).onTerminate(() -> {
+            cancelled.complete(null);
+        }).takeWhile((t) -> false).toList().run();
+        cancelled.get(1, TimeUnit.SECONDS);
+    }
 }

From b04903fc5bb011a02b47c29b8850605aff86cbd0 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 10 Dec 2019 16:24:23 +0100
Subject: [PATCH 45/66] Passing 1190 failing 50/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/RSCompatibleProcessor.java       | 27 ++-----
 .../reactive/CoupledProcessor.java            |  3 +-
 .../reactive/OnErrorResumeProcessor.java      |  3 -
 .../RedeemingCompletionSubscriber.java        |  2 -
 .../reactive/hybrid/HybridSubscriber.java     | 80 +++++--------------
 .../reactive/AbstractProcessorTest.java       | 53 ++++++++----
 .../reactive/ConcatProcessorTest.java         | 44 ++++++++++
 7 files changed, 111 insertions(+), 101 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index 7b03e51c101..f6f137aca41 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -17,7 +17,6 @@
 
 package io.helidon.common.reactive;
 
-import java.lang.ref.WeakReference;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
@@ -144,12 +143,10 @@ public void onError(Throwable ex) {
 
     public static class ReferencedSubscriber implements Flow.Subscriber {
 
-        private Flow.Subscriber subscriber;
-        private WeakReference> subscriberWeakReference;
+        private Optional> subscriber = Optional.empty();
 
         private ReferencedSubscriber(Flow.Subscriber subscriber) {
-            //Objects.requireNonNull(subscriber);
-            this.subscriber = subscriber;
+            this.subscriber = Optional.of(subscriber);
         }
 
         public static  ReferencedSubscriber create(Flow.Subscriber subscriber) {
@@ -157,37 +154,27 @@ public static  ReferencedSubscriber create(Flow.Subscriber subscriber)
         }
 
         public void releaseReference() {
-            this.subscriberWeakReference = new WeakReference<>(this.subscriber);
-            this.subscriber = null;
-        }
-
-        private Flow.Subscriber getSubscriberReference() {
-            if (Objects.nonNull(subscriber)) {
-                return subscriber;
-            } else if (Objects.nonNull(subscriberWeakReference)) {
-                return subscriberWeakReference.get();
-            }
-            return null;
+            this.subscriber = Optional.empty();
         }
 
         @Override
         public void onSubscribe(Flow.Subscription subscription) {
-            subscriber.onSubscribe(subscription);
+            subscriber.ifPresent(s -> s.onSubscribe(subscription));
         }
 
         @Override
         public void onNext(T item) {
-            getSubscriberReference().onNext(item);
+            subscriber.ifPresent(s -> s.onNext(item));
         }
 
         @Override
         public void onError(Throwable throwable) {
-            getSubscriberReference().onError(throwable);
+            subscriber.ifPresent(s -> s.onError(throwable));
         }
 
         @Override
         public void onComplete() {
-            getSubscriberReference().onComplete();
+            subscriber.ifPresent(Flow.Subscriber::onComplete);
         }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index 37f84579cd0..4144ef01e52 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -53,11 +53,13 @@ public void onSubscribe(Subscription downStreamsSubscription) {
             @Override
             @SuppressWarnings("unchecked")
             public void onNext(T t) {
+                Objects.requireNonNull(t);
                 downStreamSubscriber.onNext((R) t);
             }
 
             @Override
             public void onError(Throwable t) {
+                Objects.requireNonNull(t);
                 upStreamSubscription.cancel();
                 subscriber.onError(t);
                 downStreamSubscriber.onError(t);
@@ -120,7 +122,6 @@ public void onError(Throwable t) {
     @Override
     public void onComplete() {
         subscriber.onComplete();
-        upStreamSubscription.cancel();
         downStreamSubscriber.onComplete();
         downStreamsSubscription.cancel();
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index c97ffa78e42..0840ce93dd1 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -86,12 +86,10 @@ public void onError(Throwable ex) {
 
             } else {
                 publisherSupplier.apply(ex).subscribe(new Subscriber() {
-                    private Subscription subscription;
 
                     @Override
                     public void onSubscribe(Subscription subscription) {
                         Objects.requireNonNull(subscription);
-                        this.subscription = subscription;
                         onErrorPublisherSubscription = Optional.of(subscription);
                         if (getRequestedCounter().get() > 0) {
                             subscription.request(getRequestedCounter().get());
@@ -118,7 +116,6 @@ public void onComplete() {
             }
         } catch (Throwable t) {
             onErrorPublisherSubscription.ifPresent(Subscription::cancel);
-            getSubscription().ifPresent(Flow.Subscription::cancel);
             superError(t);
         }
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index 444747b4ebe..6fa95dd2dbd 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -78,8 +78,6 @@ public void request(long n) {
             public void cancel() {
                 s.cancel();
                 completion.toCompletableFuture().completeExceptionally(new CancellationException());
-                //Base processor breaks cancel->onComplete loop, so listen even for downstream call
-                //completion.toCompletableFuture().complete(null);
             }
         });
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 7cef9dbcd18..1e5ee709589 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -17,11 +17,10 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
-import java.lang.ref.WeakReference;
-import java.security.InvalidParameterException;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Consumer;
+import java.util.logging.Logger;
 
 import io.helidon.common.reactive.Flow;
 
@@ -37,20 +36,20 @@
  */
 public class HybridSubscriber implements Flow.Subscriber, Subscriber {
 
-    private Flow.Subscriber flowSubscriber;
-    private Subscriber reactiveSubscriber;
-    private WeakReference> reactiveSubscriberWeakRefecence;
-    private WeakReference> flowSubscriberWeakRefecence;
+    private static final Logger LOGGER = Logger.getLogger(HybridSubscriber.class.getName());
+
+    private Optional> flowSubscriber = Optional.empty();
+    private Optional> reactiveSubscriber = Optional.empty();
     private Type type;
 
     private HybridSubscriber(Flow.Subscriber subscriber) {
         this.type = Type.FLOW;
-        this.flowSubscriber = subscriber;
+        this.flowSubscriber = Optional.of(subscriber);
     }
 
     private HybridSubscriber(Subscriber subscriber) {
         this.type = Type.RS;
-        this.reactiveSubscriber = subscriber;
+        this.reactiveSubscriber = Optional.of(subscriber);
     }
 
     /**
@@ -85,77 +84,38 @@ public static  HybridSubscriber from(Subscriber subscriber) {
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
-        if (flowSubscriber != null) {
-            flowSubscriber.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences));
-        } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences));
-        } else {
-            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
-        }
+        flowSubscriber.ifPresent(s -> s.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences)));
+        reactiveSubscriber.ifPresent(s -> s.onSubscribe(HybridSubscription.from(subscription).onCancel(this::releaseReferences)));
     }
 
     @Override
     public void onSubscribe(Subscription subscription) {
         Objects.requireNonNull(subscription);
-        if (flowSubscriber != null) {
-            flowSubscriber.onSubscribe(HybridSubscription.from(subscription));
-        } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onSubscribe(HybridSubscription.from(subscription));
-        } else {
-            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
-        }
+        flowSubscriber.ifPresent(s -> s.onSubscribe(HybridSubscription.from(subscription)));
+        reactiveSubscriber.ifPresent(s -> s.onSubscribe(subscription));
     }
 
     @Override
     public void onNext(T item) {
-        doWithAvailableSubscriber(
-                rsSubscriber -> rsSubscriber.onNext(item),
-                flowSubscriber -> flowSubscriber.onNext(item));
+        flowSubscriber.ifPresent(s -> s.onNext(item));
+        reactiveSubscriber.ifPresent(s -> s.onNext(item));
     }
 
     @Override
-    public void onError(Throwable throwable) {
-        if (flowSubscriber != null) {
-            flowSubscriber.onError(throwable);
-        } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onError(throwable);
-        } else {
-            throw new InvalidParameterException("Hybrid subscriber has no subscriber");
-        }
+    public void onError(Throwable t) {
+        flowSubscriber.ifPresent(s -> s.onError(t));
+        reactiveSubscriber.ifPresent(s -> s.onError(t));
     }
 
     @Override
     public void onComplete() {
-        if (flowSubscriber != null) {
-            flowSubscriber.onComplete();
-        } else if (reactiveSubscriber != null) {
-            reactiveSubscriber.onComplete();
-        }
-    }
-
-    private void doWithAvailableSubscriber(Consumer> rsConsumer, Consumer> flowConsumer) {
-        if (type == Type.FLOW) {
-            if (Objects.nonNull(flowSubscriber)) {
-                flowConsumer.accept(flowSubscriber);
-            } else {
-                Optional.ofNullable(flowSubscriberWeakRefecence.get())
-                        .ifPresent(flowConsumer::accept);
-            }
-        } else if (type == Type.RS) {
-            if (Objects.nonNull(reactiveSubscriber)) {
-                rsConsumer.accept(reactiveSubscriber);
-            } else {
-                Optional.ofNullable(reactiveSubscriberWeakRefecence.get())
-                        .ifPresent(rsConsumer::accept);
-            }
-        }
+        flowSubscriber.ifPresent(Flow.Subscriber::onComplete);
+        reactiveSubscriber.ifPresent(Subscriber::onComplete);
     }
 
     public void releaseReferences() {
-        flowSubscriberWeakRefecence = new WeakReference<>(flowSubscriber);
-        reactiveSubscriberWeakRefecence = new WeakReference<>(reactiveSubscriber);
-        flowSubscriber = null;
-        reactiveSubscriber = null;
+        flowSubscriber = Optional.empty();
+        reactiveSubscriber = Optional.empty();
     }
 
     private enum Type {
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index 92a15f9bb81..83274448383 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -25,11 +25,17 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import io.helidon.common.reactive.Flow;
+import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -37,16 +43,34 @@
 
 public abstract class AbstractProcessorTest {
 
-    protected abstract Processor getProcessor();
+    @SuppressWarnings("unchecked")
+    protected Processor getProcessor() {
+        Flow.Processor processor = (Flow.Processor) TappedProcessor.create();
+        return HybridProcessor.from(processor);
+    }
 
     protected abstract Processor getFailedProcessor(RuntimeException t);
 
+    protected Publisher getPublisher(long items) {
+        if (items < 1) {
+            return new MockPublisher();
+        } else {
+            return ReactiveStreams.fromIterable(LongStream.range(0, items).boxed().collect(Collectors.toList())).buildRs();
+        }
+    }
+
+    private MockPublisher getMockPublisher() {
+        Publisher pub = getPublisher(-5);
+        assumeTrue(pub instanceof MockPublisher);
+        return (MockPublisher) pub;
+    }
+
     /**
      * https://github.com/reactive-streams/reactive-streams-jvm#1.1
      */
     @Test
     void requestCount() {
-        MockPublisher p = new MockPublisher();
+        MockPublisher p = getMockPublisher();
         testProcessor(ReactiveStreams.fromPublisher(p).via(getProcessor()).buildRs(), s -> {
             s.expectRequestCount(0);
             s.request(1);
@@ -67,13 +91,13 @@ void requestCount() {
      */
     @Test
     void nextAfterCancel() {
-        MockPublisher p = new MockPublisher();
+        MockPublisher p = getMockPublisher();
         testProcessor(ReactiveStreams.fromPublisher(p).via(getProcessor()).buildRs(), s -> {
-            s.request(2);
-            s.cancel();
+            s.request(4);
             p.sendNext(2);
+            s.cancel();
             p.sendNext(4);
-            s.expectSum(6);
+            s.expectSum(2);
         });
     }
 
@@ -83,7 +107,7 @@ void nextAfterCancel() {
     @Test
     void cancel2ndSubscription() throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture cancelled = new CompletableFuture<>();
-        MockPublisher p = new MockPublisher();
+        Publisher p = getPublisher(4);
         Processor processor = getProcessor();
         testProcessor(ReactiveStreams.fromPublisher(p).via(processor).buildRs(), s -> {
             s.request(2);
@@ -107,7 +131,7 @@ public void cancel() {
 
     @Test
     void onCompletePropagation() {
-        testProcessor(ReactiveStreams.of(1L, 2L, 3L).via(getProcessor()).buildRs(), s -> {
+        testProcessor(ReactiveStreams.fromPublisher(getPublisher(3)).via(getProcessor()).buildRs(), s -> {
             s.request(1);
             s.expectRequestCount(1);
             s.request(2);
@@ -118,18 +142,17 @@ void onCompletePropagation() {
 
     @Test
     void requestCountProcessorTest() {
-        testProcessor(ReactiveStreams.generate(() -> 4L).via(getProcessor()).buildRs(), s -> {
+        testProcessor(ReactiveStreams.fromPublisher(getPublisher(1_000_400L)).via(getProcessor()).buildRs(), s -> {
             s.request(15);
             s.expectRequestCount(15);
             s.request(2);
             s.expectRequestCount(17);
-            s.expectSum(17 * 4);
         });
     }
 
     @Test
     void longOverFlow() {
-        testProcessor(ReactiveStreams.generate(() -> 4L).via(getProcessor()).buildRs(), s -> {
+        testProcessor(ReactiveStreams.fromPublisher(getPublisher(1_000_400L)).via(getProcessor()).buildRs(), s -> {
             s.cancelAfter(1_000_000L);
             s.request(Long.MAX_VALUE - 1);
             s.request(Long.MAX_VALUE - 1);
@@ -139,9 +162,9 @@ void longOverFlow() {
     @Test
     void cancelOnError() throws InterruptedException, ExecutionException, TimeoutException {
         Processor failedProcessor = getFailedProcessor(new TestRuntimeException());
-        Assumptions.assumeTrue(Objects.nonNull(failedProcessor));
+        assumeTrue(Objects.nonNull(failedProcessor));
         CompletableFuture cancelled = new CompletableFuture<>();
-        CompletionStage> result = ReactiveStreams.generate(() -> 4L)
+        CompletionStage> result = ReactiveStreams.fromPublisher(getPublisher(1_000_000L))
                 .onTerminate(() -> cancelled.complete(null))
                 .via(failedProcessor)
                 .toList()
@@ -158,7 +181,7 @@ void finiteOnCompleteTest() throws InterruptedException, ExecutionException, Tim
     private  void finiteOnCompleteTest(Processor processor)
             throws InterruptedException, ExecutionException, TimeoutException {
         CompletableFuture completed = new CompletableFuture<>();
-        ReactiveStreams.of(1L, 2L, 3L)
+        ReactiveStreams.fromPublisher(getPublisher(3))
                 .via(processor)
                 .onComplete(() -> completed.complete(null))
                 .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java
new file mode 100644
index 00000000000..4eea0677e01
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+public class ConcatProcessorTest extends AbstractProcessorTest {
+
+    @Override
+    protected Publisher getPublisher(long items) {
+        ;
+        return ReactiveStreams.concat(
+                ReactiveStreams.fromIterable(LongStream.range(0, items / 2).boxed().collect(Collectors.toList())),
+                ReactiveStreams.fromIterable(LongStream.range(items / 2, items).boxed().collect(Collectors.toList()))
+        ).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.builder().peek(o -> {
+            throw new TestRuntimeException();
+        }).buildRs();
+    }
+}

From ec0d4f2cb4aa4713da6baf302f99e43a8790bacf Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 12 Dec 2019 16:01:04 +0100
Subject: [PATCH 46/66] Passing 1202 failing 44/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/CollectSubscriber.java           |  10 +-
 .../FlatMapCompletionStageProcessor.java      | 163 ++++++++++++++++++
 .../reactive/FlatMapProcessor.java            | 131 ++++++++------
 .../microprofile/reactive/GraphBuilder.java   |   2 +-
 .../reactive/CountingSubscriber.java          |   2 +-
 .../FlatMapCompletionStageProcessorTest.java  | 108 ++++++++++++
 .../FlatMapPublisherProcessorTest.java        |  73 ++++++++
 .../microrofile/reactive/MockPublisher.java   |   9 +
 8 files changed, 444 insertions(+), 54 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index da129acf2f1..4842f2f5c34 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -100,24 +100,25 @@ public void onSubscribe(Subscription s) {
                 // https://github.com/reactive-streams/reactive-streams-jvm#2.5
                 if (Objects.nonNull(this.subscription)) {
                     s.cancel();
+                    return;
                 }
+                this.subscription = s;
                 try {
                     cumulatedVal = collectStage.getCollector().supplier().get();
                 } catch (Throwable t) {
                     onError(t);
                     s.cancel();
                 }
-                this.subscription = s;
-                subscription.request(1);
+                subscription.request(Long.MAX_VALUE);
             }
 
             @Override
             @SuppressWarnings("unchecked")
             public void onNext(Object item) {
+                Objects.requireNonNull(item);
                 if (!closed.get()) {
                     try {
                         accumulator.accept(cumulatedVal, item);
-                        subscription.request(1);
                     } catch (Throwable t) {
                         onError(t);
                         subscription.cancel();
@@ -127,6 +128,7 @@ public void onNext(Object item) {
 
             @Override
             public void onError(Throwable t) {
+                Objects.requireNonNull(t);
                 completableFuture.completeExceptionally(t);
             }
 
@@ -179,11 +181,13 @@ public void onSubscribe(Subscription s) {
 
             @Override
             public void onNext(Object o) {
+                Objects.requireNonNull(o);
                 subscriber.onNext(o);
             }
 
             @Override
             public void onError(Throwable t) {
+                Objects.requireNonNull(t);
                 subscriber.onError(t);
             }
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java
new file mode 100644
index 00000000000..4fb1a7e30ae
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class FlatMapCompletionStageProcessor implements Processor {
+
+    private Subscription upstreamSubscription;
+    private Optional> downStreamSubscriber = Optional.empty();
+    private CSBuffer buffer;
+    private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
+
+    @SuppressWarnings("unchecked")
+    public FlatMapCompletionStageProcessor(Function> mapper) {
+        Function> csMapper = (Function>) mapper;
+        buffer = new CSBuffer<>(csMapper);
+    }
+
+    @Override
+    public void subscribe(Subscriber subscriber) {
+        downStreamSubscriber = Optional.of(subscriber);
+        if (Objects.nonNull(this.upstreamSubscription)) {
+            subscriber.onSubscribe(new InnerSubscription());
+        }
+    }
+
+    @Override
+    public void onSubscribe(Subscription upstreamSubscription) {
+        if (Objects.nonNull(this.upstreamSubscription)) {
+            upstreamSubscription.cancel();
+            return;
+        }
+        this.upstreamSubscription = upstreamSubscription;
+        downStreamSubscriber.ifPresent(s -> s.onSubscribe(new InnerSubscription()));
+    }
+
+    private class InnerSubscription implements Subscription {
+        @Override
+        public void request(long n) {
+            upstreamSubscription.request(n);
+        }
+
+        @Override
+        public void cancel() {
+            upstreamSubscription.cancel();
+        }
+    }
+
+    @Override
+    public void onNext(Object o) {
+        Objects.requireNonNull(o);
+        buffer.offer(o);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        Objects.requireNonNull(t);
+        downStreamSubscriber.get().onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        onCompleteReceivedAlready.set(true);
+        if (buffer.isComplete()) {
+            //Have to wait for all CS to be finished
+            downStreamSubscriber.get().onComplete();
+        }
+    }
+
+    private class CSBuffer {
+
+        private BlockingQueue buffer = new ArrayBlockingQueue<>(64);
+        private Function> mapper;
+        private CompletableFuture lastCs = null;
+        private ReentrantLock bufferLock = new ReentrantLock();
+
+        @SuppressWarnings("unchecked")
+        public CSBuffer(Function> mapper) {
+            this.mapper = o -> (CompletionStage) mapper.apply(o);
+        }
+
+        public boolean isComplete() {
+            return Objects.isNull(lastCs) || (lastCs.isDone() && buffer.isEmpty());
+        }
+
+        @SuppressWarnings("unchecked")
+        public void tryNext(Object o, Throwable t) {
+            bufferLock.lock();
+            if (Objects.nonNull(t)) {
+                upstreamSubscription.cancel();
+                downStreamSubscriber.get().onError(t);
+            }
+
+            if (Objects.isNull(o)) {
+                upstreamSubscription.cancel();
+                downStreamSubscriber.get().onError(new NullPointerException());
+            }
+            downStreamSubscriber.get().onNext((U) o);
+            Object nextItem = buffer.poll();
+            if (Objects.nonNull(nextItem)) {
+                lastCs = executeMapper(nextItem);
+                lastCs.whenComplete(this::tryNext);
+            } else if (onCompleteReceivedAlready.get()) {
+                // Received onComplete and all CS are done
+                downStreamSubscriber.get().onComplete();
+            }
+            bufferLock.unlock();
+        }
+
+        public void offer(Object o) {
+            bufferLock.lock();
+            if (buffer.isEmpty() && (Objects.isNull(lastCs) || lastCs.isDone())) {
+                lastCs = executeMapper(o);
+                lastCs.whenComplete(this::tryNext);
+            } else {
+                buffer.offer(o);
+            }
+            bufferLock.unlock();
+        }
+
+        public CompletableFuture executeMapper(Object item) {
+            CompletableFuture cs;
+            try {
+                cs = mapper.apply(item).toCompletableFuture();
+            } catch (Throwable t) {
+                upstreamSubscription.cancel();
+                downStreamSubscriber.get().onError(t);
+                //TODO: CompletableFuture.failedFuture since Java 9
+                cs = new CompletableFuture<>();
+                cs.completeExceptionally(t);
+            }
+            return cs;
+        }
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index fd542233804..a2f0560199a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -19,7 +19,8 @@
 
 import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
@@ -39,16 +40,18 @@
 public class FlatMapProcessor implements Processor {
 
     private Function mapper;
-
-    private final AtomicBoolean innerPublisherCompleted = new AtomicBoolean(true);
     private HybridSubscriber subscriber;
     private Subscription subscription;
     private final AtomicLong requestCounter = new AtomicLong();
     private Subscription innerSubscription;
+    private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
+
+    private PublisherBuffer buffer;
 
     private Optional error = Optional.empty();
 
     private FlatMapProcessor() {
+        buffer = new PublisherBuffer();
     }
 
     @SuppressWarnings("unchecked")
@@ -67,45 +70,17 @@ static FlatMapProcessor fromPublisherMapper(Function mapper) {
         return flatMapProcessor;
     }
 
-    @SuppressWarnings("unchecked")
-    static FlatMapProcessor fromCompletionStage(Function> mapper) {
-        Function> csMapper = (Function>) mapper;
-        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
-        flatMapProcessor.mapper = o -> (Publisher) s -> {
-            AtomicBoolean requested = new AtomicBoolean(false);
-            s.onSubscribe(new Subscription() {
-                @Override
-                public void request(long n) {
-                    //Only one request supported
-                    if (!requested.getAndSet(true)) {
-                        csMapper.apply(o).whenComplete((payload, throwable) -> {
-                            if (Objects.nonNull(throwable)) {
-                                s.onError(throwable);
-                            } else {
-                                if (Objects.isNull(payload)) {
-                                    s.onError(new NullPointerException());
-                                } else {
-                                    s.onNext(payload);
-                                    s.onComplete();
-                                }
-                            }
-                        });
-                    }
-                }
-
-                @Override
-                public void cancel() {
-                }
-            });
-        };
-        return flatMapProcessor;
-    }
-
     private class FlatMapSubscription implements Subscription {
         @Override
         public void request(long n) {
-            requestCounter.addAndGet(n);
-            if (innerPublisherCompleted.getAndSet(false) || Objects.isNull(innerSubscription)) {
+            //TODO: Create some kind of reusable request counter
+            try {
+                requestCounter.set(Math.addExact(requestCounter.get(), n));
+            } catch (ArithmeticException e) {
+                requestCounter.set(Long.MAX_VALUE);
+            }
+
+            if (buffer.isComplete() || Objects.isNull(innerSubscription)) {
                 subscription.request(requestCounter.get());
             } else {
                 innerSubscription.request(requestCounter.get());
@@ -134,6 +109,7 @@ public void subscribe(Subscriber subscriber) {
     public void onSubscribe(Subscription subscription) {
         if (Objects.nonNull(this.subscription)) {
             subscription.cancel();
+            return;
         }
         this.subscription = subscription;
         if (Objects.nonNull(subscriber)) {
@@ -145,13 +121,7 @@ public void onSubscribe(Subscription subscription) {
     @SuppressWarnings("unchecked")
     public void onNext(Object o) {
         Objects.requireNonNull(o);
-        try {
-            Publisher publisher = mapper.apply(o);
-            publisher.subscribe(new InnerSubscriber());
-        } catch (Throwable e) {
-            this.subscription.cancel();
-            this.onError(e);
-        }
+        buffer.offer(o);
     }
 
     @Override
@@ -164,15 +134,69 @@ public void onError(Throwable t) {
 
     @Override
     public void onComplete() {
-        subscriber.onComplete();
+        onCompleteReceivedAlready.set(true);
+        if (buffer.isComplete()) {
+            //Have to wait for all Publishers to be finished
+            subscriber.onComplete();
+        }
+    }
+
+    private class PublisherBuffer {
+        private BlockingQueue buffer = new ArrayBlockingQueue<>(64);
+        private InnerSubscriber lastSubscriber = null;
+
+        public boolean isComplete() {
+            return Objects.isNull(lastSubscriber) || (lastSubscriber.isDone() && buffer.isEmpty());
+        }
+
+        public void tryNext() {
+            Object nextItem = buffer.poll();
+            if (Objects.nonNull(nextItem)) {
+                lastSubscriber = executeMapper(nextItem);
+                lastSubscriber.whenComplete(this::tryNext);
+            } else if (onCompleteReceivedAlready.get()) {
+                // Received onComplete and all Publishers are done
+                subscriber.onComplete();
+            }
+        }
+
+        public void offer(Object o) {
+            if (buffer.isEmpty() && (Objects.isNull(lastSubscriber) || lastSubscriber.isDone())) {
+                lastSubscriber = executeMapper(o);
+                lastSubscriber.whenComplete(this::tryNext);
+            } else {
+                buffer.offer(o);
+            }
+        }
+
+        public InnerSubscriber executeMapper(Object item) {
+            InnerSubscriber innerSubscriber = null;
+            try {
+                innerSubscriber = new InnerSubscriber();
+                mapper.apply(item).subscribe(innerSubscriber);
+            } catch (Throwable t) {
+                subscription.cancel();
+                subscriber.onError(t);
+            }
+            return innerSubscriber;
+        }
     }
 
     private class InnerSubscriber implements Subscriber {
 
+        private AtomicBoolean subscriptionAcked = new AtomicBoolean(false);
+        private AtomicBoolean done = new AtomicBoolean(false);
+
+        private Optional whenCompleteObserver = Optional.empty();
+
         @Override
         public void onSubscribe(Subscription innerSubscription) {
             Objects.requireNonNull(innerSubscription);
-            innerPublisherCompleted.set(false);
+            if (subscriptionAcked.get()) {
+                innerSubscription.cancel();
+                return;
+            }
+            subscriptionAcked.set(true);
             FlatMapProcessor.this.innerSubscription = innerSubscription;
             long requestCount = requestCounter.get();
             if (requestCount > 0) {
@@ -199,11 +223,20 @@ public void onError(Throwable t) {
 
         @Override
         public void onComplete() {
-            innerPublisherCompleted.set(true);
+            done.set(true);
+            whenCompleteObserver.ifPresent(Runnable::run);
             long requestCount = requestCounter.get();
             if (requestCount > 0) {
                 subscription.request(requestCount);
             }
         }
+
+        private void whenComplete(Runnable whenCompleteObserver) {
+            this.whenCompleteObserver = Optional.of(whenCompleteObserver);
+        }
+
+        private boolean isDone() {
+            return done.get();
+        }
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 7c41f0f440a..d4710be9afe 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -113,7 +113,7 @@ private GraphBuilder() {
             addProcessor(FlatMapProcessor.fromIterableMapper(stage.getMapper()));
         });
         registerStage(Stage.FlatMapCompletionStage.class, stage -> {
-            addProcessor(FlatMapProcessor.fromCompletionStage(stage.getMapper()));
+            addProcessor(new FlatMapCompletionStageProcessor(stage.getMapper()));
         });
         registerStage(Stage.Coupled.class, stage -> {
             Subscriber subscriber = GraphBuilder.create()
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
index 79c860fcddc..21e9a0b63e1 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CountingSubscriber.java
@@ -83,7 +83,7 @@ public AtomicLong getSum() {
     }
 
     public void expectRequestCount(int n) {
-        assertEquals(n, requestCount.get(), String.format("Expected %d requests but only %d received.", n, requestCount.get()));
+        assertEquals(n, requestCount.get(), String.format("Expected %d requests but only %d received.", n, (long)requestCount.get()));
     }
 
     public void expectSum(long n) {
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
index 14a19bdb91a..638ed975487 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapCompletionStageProcessorTest.java
@@ -17,9 +17,22 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Function;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 
 public class FlatMapCompletionStageProcessorTest extends AbstractProcessorTest {
@@ -34,4 +47,99 @@ protected Processor getFailedProcessor(RuntimeException t) {
             throw t;
         }).buildRs();
     }
+
+    @Test
+    void futuresMapping() throws InterruptedException, TimeoutException, ExecutionException {
+        CompletableFuture one = new CompletableFuture<>();
+        CompletableFuture two = new CompletableFuture<>();
+        CompletableFuture three = new CompletableFuture<>();
+
+        CompletionStage> result = ReactiveStreams.of(one, two, three)
+                .flatMapCompletionStage(i -> i)
+                .toList()
+                .run();
+
+        Thread.sleep(100);
+
+        one.complete(1);
+        two.complete(2);
+        three.complete(3);
+
+        assertEquals(Arrays.asList(1, 2, 3), result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void futuresOrder() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture one = new CompletableFuture<>();
+        CompletableFuture two = new CompletableFuture<>();
+        CompletableFuture three = new CompletableFuture<>();
+
+        CompletionStage> result = ReactiveStreams.of(one, two, three)
+                .flatMapCompletionStage(Function.identity())
+                .toList()
+                .run();
+
+        three.complete(3);
+        Thread.sleep(100);
+        two.complete(2);
+        Thread.sleep(100);
+        one.complete(1);
+
+        assertEquals(Arrays.asList(1, 2, 3), result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void oneAtTime() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture one = new CompletableFuture<>();
+        CompletableFuture two = new CompletableFuture<>();
+        CompletableFuture three = new CompletableFuture<>();
+
+        AtomicInteger concurrentMaps = new AtomicInteger(0);
+        AtomicLong c = new AtomicLong(0);
+        CompletionStage> result = ReactiveStreams.of(one, two, three)
+                .flatMapCompletionStage(i -> {
+                    assertEquals(1, concurrentMaps.incrementAndGet(), ">>" + c.incrementAndGet());
+                    return i;
+                })
+                .toList()
+                .run();
+
+        Thread.sleep(100);
+        concurrentMaps.decrementAndGet();
+        one.complete(1);
+        Thread.sleep(100);
+        concurrentMaps.decrementAndGet();
+        two.complete(2);
+        Thread.sleep(100);
+        concurrentMaps.decrementAndGet();
+        three.complete(3);
+
+        assertEquals(Arrays.asList(1, 2, 3), result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void failOnNull() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.generate(() -> 4).onTerminate(() -> cancelled.complete(null))
+                .flatMapCompletionStage(t -> CompletableFuture.completedFuture(null))
+                .toList().run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void failedCs() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        CompletionStage> result = ReactiveStreams.generate(() -> 4)
+                .onTerminate(() -> cancelled.complete(null))
+                .flatMapCompletionStage(i -> {
+                    CompletableFuture failed = new CompletableFuture<>();
+                    failed.completeExceptionally(new TestRuntimeException());
+                    return failed;
+                })
+                .toList()
+                .run();
+        cancelled.get(1, TimeUnit.SECONDS);
+        assertThrows(ExecutionException.class, () -> result.toCompletableFuture().get(1, TimeUnit.SECONDS), TestRuntimeException.TEST_MSG);
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
index 78a1a7ba159..5a0fb6c48b0 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapPublisherProcessorTest.java
@@ -17,8 +17,25 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 
 public class FlatMapPublisherProcessorTest extends AbstractProcessorTest {
     @Override
@@ -32,4 +49,60 @@ protected Processor getFailedProcessor(RuntimeException t) {
             throw t;
         }).buildRs();
     }
+
+    @Test
+    void onePublisherAtTime() throws InterruptedException, ExecutionException, TimeoutException {
+        AtomicInteger counter = new AtomicInteger();
+        List pubs = Arrays.asList(new MockPublisher(), new MockPublisher());
+        List> builders = pubs.stream()
+                .peek(mockPublisher -> mockPublisher.observeSubscribe(s -> {
+                    assertEquals(1, counter.incrementAndGet(),
+                            "Another publisher already subscribed to!!");
+                }))
+                .map(ReactiveStreams::fromPublisher)
+                .collect(Collectors.toList());
+
+        CompletionStage> result =
+                ReactiveStreams.of(0, 1)
+                        .flatMap(builders::get)
+                        .toList()
+                        .run();
+
+        counter.decrementAndGet();
+        pubs.get(0).sendOnComplete();
+        counter.decrementAndGet();
+        pubs.get(1).sendOnComplete();
+
+        result.toCompletableFuture().get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void innerProcessorSecondSubscriptionTest() throws InterruptedException, ExecutionException, TimeoutException {
+        CompletableFuture cancelled = new CompletableFuture<>();
+        Subscription secondSubscription = new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+                cancelled.complete(null);
+            }
+        };
+
+        MockPublisher publisher = new MockPublisher();
+        final AtomicReference> subs = new AtomicReference<>();
+        publisher.observeSubscribe(subscriber -> subs.set((Subscriber) subscriber));
+
+        CompletionStage> result =
+                ReactiveStreams.of(0)
+                        .flatMap(integer -> ReactiveStreams.fromPublisher(publisher))
+                        .toList()
+                        .run();
+
+        subs.get().onSubscribe(secondSubscription);
+        publisher.sendOnComplete();
+
+        cancelled.get(1, TimeUnit.SECONDS);
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
index 63a95f82cec..71121090f18 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MockPublisher.java
@@ -17,16 +17,21 @@
 
 package io.helidon.microrofile.reactive;
 
+import java.util.Optional;
+import java.util.function.Consumer;
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
 public class MockPublisher implements Publisher {
     private Subscriber subscriber;
+    private Optional>> subscriberObserver = Optional.empty();
 
     @Override
     public void subscribe(Subscriber subscriber) {
         this.subscriber = subscriber;
+        subscriberObserver.ifPresent(o -> o.accept(subscriber));
         subscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
@@ -40,6 +45,10 @@ public void cancel() {
         });
     }
 
+    public void observeSubscribe(Consumer> subscriberObserver) {
+        this.subscriberObserver = Optional.of(subscriberObserver);
+    }
+
     public void sendNext(long value) {
         subscriber.onNext(value);
     }

From 124869cd7a0304b0fa3510310008fbeffe889e52 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 13 Dec 2019 08:50:28 +0100
Subject: [PATCH 47/66] Passing 1208 failing 36/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../helidon/microprofile/reactive/OfPublisher.java  | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index a041b80640c..17ed7cdd9e7 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -26,6 +26,7 @@
 public class OfPublisher implements Flow.Publisher {
     private Iterable iterable;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
+    private AtomicBoolean completed = new AtomicBoolean(false);
 
     public OfPublisher(Iterable iterable) {
         this.iterable = iterable;
@@ -33,7 +34,13 @@ public OfPublisher(Iterable iterable) {
 
     @Override
     public void subscribe(Flow.Subscriber subscriber) {
-        final Iterator iterator = iterable.iterator();
+        final Iterator iterator;
+        try {
+            iterator = iterable.iterator();
+        } catch (Throwable t) {
+            subscriber.onError(t);
+            return;
+        }
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
@@ -47,7 +54,9 @@ public void request(long n) {
                         Objects.requireNonNull(next);
                         subscriber.onNext(next);
                     } else {
-                        subscriber.onComplete();
+                        if (!completed.getAndSet(true)) {
+                            subscriber.onComplete();
+                        }
                         break;
                     }
                 }

From 934a93acc872092105c76a71fc09416b60251b61 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 13 Dec 2019 14:48:07 +0100
Subject: [PATCH 48/66] After rebase fix

Signed-off-by: Daniel Kec 
---
 messaging/kafka/pom.xml                                  | 4 ----
 microprofile/messaging/pom.xml                           | 8 +++-----
 .../microprofile/messaging/channel/ChannelRouter.java    | 3 +--
 .../messaging/connector/AdHocConfigBuilder.java          | 6 +-----
 .../helidon/microprofile/messaging/AbstractCDITest.java  | 9 +++------
 microprofile/reactive-streams/pom.xml                    | 2 +-
 .../reactive/FlatMapCompletionStageProcessor.java        | 4 +---
 microprofile/tests/tck/tck-messaging/pom.xml             | 6 +++---
 microprofile/tests/tck/tck-reactive-operators/pom.xml    | 2 +-
 9 files changed, 14 insertions(+), 30 deletions(-)

diff --git a/messaging/kafka/pom.xml b/messaging/kafka/pom.xml
index f917bd8e6f7..c35e50653f7 100644
--- a/messaging/kafka/pom.xml
+++ b/messaging/kafka/pom.xml
@@ -68,10 +68,6 @@
             io.helidon.microprofile.config
             helidon-microprofile-config
         
-        
-            io.helidon.microprofile.config
-            helidon-microprofile-config-cdi
-        
         
             io.helidon.microprofile.server
             helidon-microprofile-server
diff --git a/microprofile/messaging/pom.xml b/microprofile/messaging/pom.xml
index 426f13a7632..789f16b4c0d 100644
--- a/microprofile/messaging/pom.xml
+++ b/microprofile/messaging/pom.xml
@@ -22,7 +22,7 @@
     
         io.helidon.microprofile
         helidon-microprofile-project
-        1.3.2-SNAPSHOT
+        2.0-SNAPSHOT
     
 
     helidon-microprofile-messaging
@@ -41,17 +41,15 @@
             io.helidon.microprofile.config
             helidon-microprofile-config
         
-        
-            io.helidon.microprofile.config
-            helidon-microprofile-config-cdi
-        
         
             io.helidon.microprofile.server
             helidon-microprofile-server
+            ${helidon.version}
         
         
             io.helidon.microprofile
             helidon-microprofile-reactive-streams
+            ${helidon.version}
         
         
             io.helidon.microprofile.bundles
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
index 55d1faecd81..6ee9e2387f4 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/channel/ChannelRouter.java
@@ -30,7 +30,6 @@
 import javax.enterprise.inject.spi.DeploymentException;
 
 import io.helidon.config.Config;
-import io.helidon.microprofile.config.MpConfig;
 import io.helidon.microprofile.messaging.connector.IncomingConnector;
 import io.helidon.microprofile.messaging.connector.OutgoingConnector;
 
@@ -45,7 +44,7 @@
  * Orchestrator for all found channels, methods and connectors.
  */
 public class ChannelRouter {
-    private Config config = ((MpConfig) ConfigProvider.getConfig()).helidonConfig();
+    private Config config = (Config) ConfigProvider.getConfig();
 
     private List connectableBeanMethods = new ArrayList<>();
 
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
index 433e6a08519..c8f476cbd2c 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
@@ -22,7 +22,6 @@
 import io.helidon.common.CollectionsHelper;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
-import io.helidon.microprofile.config.MpConfig;
 
 /**
  *
@@ -54,9 +53,6 @@ org.eclipse.microprofile.config.Config build() {
                 .disableEnvironmentVariablesSource()
                 .disableSystemPropertiesSource()
                 .build();
-
-        return MpConfig.builder()
-                .config(newConfig)
-                .build();
+        return (org.eclipse.microprofile.config.Config) newConfig;
     }
 }
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
index cac6d9116eb..c98e9a34a61 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/AbstractCDITest.java
@@ -37,14 +37,13 @@
 
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
-import io.helidon.microprofile.config.MpConfig;
-import io.helidon.microprofile.config.MpConfigProviderResolver;
 import io.helidon.microprofile.server.Server;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 
@@ -110,10 +109,8 @@ private static SeContainer startCdiContainer(Map p, Set
         final Server.Builder builder = Server.builder();
         assertNotNull(builder);
         builder.config(config);
-        MpConfigProviderResolver.instance()
-                .registerConfig(MpConfig.builder()
-                                .config(config).build(),
-                        Thread.currentThread().getContextClassLoader());
+        ConfigProviderResolver.instance()
+                .registerConfig((org.eclipse.microprofile.config.Config) config, Thread.currentThread().getContextClassLoader());
         final SeContainerInitializer initializer = SeContainerInitializer.newInstance();
         assertNotNull(initializer);
         initializer.addBeanClasses(beanClasses.toArray(new Class[0]));
diff --git a/microprofile/reactive-streams/pom.xml b/microprofile/reactive-streams/pom.xml
index f2d44bfee3a..dea040f1600 100644
--- a/microprofile/reactive-streams/pom.xml
+++ b/microprofile/reactive-streams/pom.xml
@@ -24,7 +24,7 @@
     
         io.helidon.microprofile
         helidon-microprofile-project
-        1.3.2-SNAPSHOT
+        2.0-SNAPSHOT
     
 
     io.helidon.microprofile
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java
index 4fb1a7e30ae..18e396fbf1b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapCompletionStageProcessor.java
@@ -153,9 +153,7 @@ public CompletableFuture executeMapper(Object item) {
             } catch (Throwable t) {
                 upstreamSubscription.cancel();
                 downStreamSubscriber.get().onError(t);
-                //TODO: CompletableFuture.failedFuture since Java 9
-                cs = new CompletableFuture<>();
-                cs.completeExceptionally(t);
+                cs = CompletableFuture.failedFuture(t);
             }
             return cs;
         }
diff --git a/microprofile/tests/tck/tck-messaging/pom.xml b/microprofile/tests/tck/tck-messaging/pom.xml
index 6e908a86c71..83994b129a1 100644
--- a/microprofile/tests/tck/tck-messaging/pom.xml
+++ b/microprofile/tests/tck/tck-messaging/pom.xml
@@ -24,7 +24,7 @@
     
         io.helidon.microprofile.tests
         tck-project
-        1.3.2-SNAPSHOT
+        2.0-SNAPSHOT
     
     tck-messaging
     Helidon Microprofile Tests TCK Messaging
@@ -38,14 +38,14 @@
             
                 
                     io.helidon.microprofile.bundles
-                    helidon-microprofile-3.1
+                    helidon-microprofile
                 
             
         
         
             io.helidon.microprofile
             helidon-microprofile-messaging
-            1.3.2-SNAPSHOT
+            2.0-SNAPSHOT
             
                 
                     io.helidon.microprofile
diff --git a/microprofile/tests/tck/tck-reactive-operators/pom.xml b/microprofile/tests/tck/tck-reactive-operators/pom.xml
index 7a80c525b05..666517c6d78 100644
--- a/microprofile/tests/tck/tck-reactive-operators/pom.xml
+++ b/microprofile/tests/tck/tck-reactive-operators/pom.xml
@@ -23,7 +23,7 @@
     
         io.helidon.microprofile.tests
         tck-project
-        1.3.2-SNAPSHOT
+        2.0-SNAPSHOT
     
     tck-reactive-operators
     Helidon Microprofile Tests TCK Reactive Streams Operators

From b49eb2e4624a9e737f0b1d20e617e40e45afd0e1 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 14 Dec 2019 01:30:22 +0100
Subject: [PATCH 49/66] Passing 1216 failing 29/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/RSCompatibleProcessor.java       |  11 +-
 .../reactive/CoupledProcessor.java            | 112 +++++++++++-------
 .../FromCompletionStagePublisher.java         |  42 ++++---
 .../reactive/OnErrorResumeProcessor.java      |   2 +-
 .../reactive/TappedSubscription.java          |  56 +++++++++
 .../microrofile/reactive/EngineTest.java      |   6 +-
 .../tests/tck/tck-reactive-operators/pom.xml  |   2 +-
 7 files changed, 169 insertions(+), 62 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index f6f137aca41..a6c38588a35 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -21,6 +21,7 @@
 import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.locks.ReentrantLock;
 
 public class RSCompatibleProcessor extends BaseProcessor {
 
@@ -29,6 +30,8 @@ public class RSCompatibleProcessor extends BaseProcessor {
     private boolean rsCompatible = false;
     private ReferencedSubscriber referencedSubscriber;
     private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
+    private ReentrantLock publisherSequentialLock = new ReentrantLock();
+
 
     public void setRSCompatible(boolean rsCompatible) {
         this.rsCompatible = rsCompatible;
@@ -77,6 +80,7 @@ protected void hookOnCancel(Flow.Subscription subscription) {
     @Override
     public void onNext(T item) {
         if (rsCompatible) {
+            publisherSequentialLock.lock();
             // https://github.com/reactive-streams/reactive-streams-jvm#2.13
             Objects.requireNonNull(item);
             try {
@@ -84,6 +88,7 @@ public void onNext(T item) {
             } catch (Throwable ex) {
                 fail(ex);
             }
+            publisherSequentialLock.unlock();
         } else {
             super.onNext(item);
         }
@@ -92,12 +97,16 @@ public void onNext(T item) {
     @Override
     public void onSubscribe(Flow.Subscription s) {
         if (rsCompatible) {
+            publisherSequentialLock.lock();
             // https://github.com/reactive-streams/reactive-streams-jvm#2.13
             Objects.requireNonNull(s);
             // https://github.com/reactive-streams/reactive-streams-jvm#2.5
             getSubscription().ifPresent(firstSubscription -> s.cancel());
+            super.onSubscribe(s);
+            publisherSequentialLock.unlock();
+        } else {
+            super.onSubscribe(s);
         }
-        super.onSubscribe(s);
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index 4144ef01e52..a8b436fa33f 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -17,93 +17,115 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-import java.util.Objects;
-
 public class CoupledProcessor implements Processor {
 
-    private Subscriber subscriber;
-    private Publisher publisher;
-    private Subscriber downStreamSubscriber;
-    private Subscription upStreamSubscription;
-    private Subscription downStreamsSubscription;
+    private Subscriber passedInSubscriber;
+    private Publisher passedInPublisher;
+    private Subscriber outletSubscriber;
+    private Subscriber inletSubscriber;
+    private Subscription inletSubscription;
+    private Subscription passedInPublisherSubscription;
 
+    private AtomicBoolean cancelled = new AtomicBoolean(false);
 
-    public CoupledProcessor(Subscriber subscriber, Publisher publisher) {
-        this.subscriber = subscriber;
-        this.publisher = publisher;
+
+    public CoupledProcessor(Subscriber passedInSubscriber, Publisher passedInPublisher) {
+        this.passedInSubscriber = passedInSubscriber;
+        this.passedInPublisher = passedInPublisher;
+        this.inletSubscriber = this;
     }
 
     @Override
-    public void subscribe(Subscriber downStreamSubscriber) {
+    public void subscribe(Subscriber outletSubscriber) {
 
-        this.downStreamSubscriber = downStreamSubscriber;
-        publisher.subscribe(new Subscriber() {
+        this.outletSubscriber = outletSubscriber;
+        passedInPublisher.subscribe(new Subscriber() {
 
             @Override
-            public void onSubscribe(Subscription downStreamsSubscription) {
-                Objects.requireNonNull(downStreamsSubscription);
-                CoupledProcessor.this.downStreamsSubscription = downStreamsSubscription;
+            public void onSubscribe(Subscription passedInPublisherSubscription) {
+                Objects.requireNonNull(passedInPublisherSubscription);
+                // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+                if (Objects.nonNull(CoupledProcessor.this.passedInPublisherSubscription) || cancelled.get()) {
+                    passedInPublisherSubscription.cancel();
+                    return;
+                }
+                CoupledProcessor.this.passedInPublisherSubscription = passedInPublisherSubscription;
             }
 
             @Override
             @SuppressWarnings("unchecked")
             public void onNext(T t) {
                 Objects.requireNonNull(t);
-                downStreamSubscriber.onNext((R) t);
+                outletSubscriber.onNext((R) t);
             }
 
             @Override
             public void onError(Throwable t) {
+                cancelled.set(true);
                 Objects.requireNonNull(t);
-                upStreamSubscription.cancel();
-                subscriber.onError(t);
-                downStreamSubscriber.onError(t);
+                outletSubscriber.onError(t);
+                passedInSubscriber.onError(t);
+                inletSubscription.cancel();
             }
 
             @Override
             public void onComplete() {
-                downStreamSubscriber.onComplete();
+                //Passed in publisher completed
+                cancelled.set(true);
+                outletSubscriber.onComplete();
+                passedInSubscriber.onComplete();
             }
         });
 
-        downStreamSubscriber.onSubscribe(new Subscription() {
+        outletSubscriber.onSubscribe(new Subscription() {
+
             @Override
             public void request(long n) {
-                downStreamsSubscription.request(n);
+                passedInPublisherSubscription.request(n);
             }
 
             @Override
             public void cancel() {
-                subscriber.onComplete();
-                downStreamsSubscription.cancel();
+                // Cancel from outlet subscriber
+                passedInSubscriber.onComplete();
+                inletSubscription.cancel();
             }
         });
     }
 
     @Override
-    public void onSubscribe(Subscription upStreamSubscription) {
-        Objects.requireNonNull(upStreamSubscription);
+    public void onSubscribe(Subscription inletSubscription) {
+        Objects.requireNonNull(inletSubscription);
         // https://github.com/reactive-streams/reactive-streams-jvm#2.5
-        if (Objects.nonNull(this.upStreamSubscription)) {
-            upStreamSubscription.cancel();
+        if (Objects.nonNull(this.inletSubscription) || cancelled.get()) {
+            inletSubscription.cancel();
+            return;
         }
-        this.upStreamSubscription = upStreamSubscription;
-        subscriber.onSubscribe(new Subscription() {
+        this.inletSubscription = inletSubscription;
+        passedInSubscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
-                upStreamSubscription.request(n);
+                inletSubscription.request(n);
             }
 
             @Override
             public void cancel() {
-                upStreamSubscription.cancel();
-                //downStreamsSubscription.cancel();//LIVELOCK!!!
-                downStreamSubscriber.onComplete();
+                // Cancel from passed in subscriber
+                cancelled.set(true);
+                inletSubscription.cancel();
+                //passedInPublisherSubscription.cancel();//LIVELOCK!!!
+                outletSubscriber.onComplete();
+                CoupledProcessor.this.outletSubscriber = null;
             }
         });
     }
@@ -111,18 +133,28 @@ public void cancel() {
     @Override
     @SuppressWarnings("unchecked")
     public void onNext(T t) {
-        subscriber.onNext(t);
+        passedInSubscriber.onNext(Objects.requireNonNull(t));
     }
 
     @Override
     public void onError(Throwable t) {
-        subscriber.onError(t);
+        cancelled.set(true);
+        // Inlet/upstream publisher sent error
+        passedInSubscriber.onError(Objects.requireNonNull(t));
+//        outletSubscriber.onError(t);
+        //passedInPublisherSubscription.cancel();
     }
 
     @Override
     public void onComplete() {
-        subscriber.onComplete();
-        downStreamSubscriber.onComplete();
-        downStreamsSubscription.cancel();
+        // Inlet/upstream publisher completed
+        cancelled.set(true);
+//        passedInPublisherSubscription.cancel();
+//        passedInSubscriber.onSubscribe(TappedSubscription.create());
+        passedInSubscriber.onComplete();
+//        outletSubscriber.onSubscribe(TappedSubscription.create());
+        outletSubscriber.onComplete();
+        passedInPublisherSubscription.cancel();
     }
+
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
index 15bf2748a81..23c99e990ee 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
@@ -19,6 +19,7 @@
 
 import java.util.Objects;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -27,7 +28,9 @@
 public class FromCompletionStagePublisher implements Publisher {
 
     private CompletionStage completionStage;
-    private boolean nullable;
+    private volatile boolean nullable;
+    private volatile boolean cancelled = false;
+    private AtomicBoolean registered = new AtomicBoolean(false);
     private Subscriber subscriber;
 
     public FromCompletionStagePublisher(CompletionStage completionStage, boolean nullable) {
@@ -43,31 +46,40 @@ public void subscribe(Subscriber subscriber) {
         subscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
+                registerEmitWhenCompleteOnceAction();
             }
 
             @Override
             public void cancel() {
-
-            }
-        });
-        completionStage.whenComplete((item, throwable) -> {
-            if (Objects.isNull(throwable)) {
-                emit((T) item);
-            } else {
-                subscriber.onError(throwable);
+                cancelled = true;
+                //registerEmitWhenCompleteOnceAction();
             }
         });
     }
 
+    private void registerEmitWhenCompleteOnceAction() {
+        if (!registered.getAndSet(true)) {
+            completionStage.whenComplete((item, throwable) -> {
+                if (Objects.isNull(throwable)) {
+                    emit((T) item);
+                } else {
+                    subscriber.onError(throwable);
+                }
+            });
+        }
+    }
+
     private void emit(T item) {
-        if (Objects.nonNull(item)) {
-            subscriber.onNext(item);
-            subscriber.onComplete();
-        } else {
-            if (nullable) {
+        if (!cancelled) {
+            if (Objects.nonNull(item)) {
+                subscriber.onNext(item);
                 subscriber.onComplete();
             } else {
-                subscriber.onError(new NullPointerException("Null in non nullable completion stage."));
+                if (nullable) {
+                    subscriber.onComplete();
+                } else {
+                    subscriber.onError(new NullPointerException("Null in non nullable completion stage."));
+                }
             }
         }
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 0840ce93dd1..8b6b04ff0b3 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -37,7 +37,7 @@ public class OnErrorResumeProcessor extends RSCompatibleProcessor {
     private AtomicBoolean completed = new AtomicBoolean(false);
     private Function supplier;
     private Function> publisherSupplier;
-    //TODO: sync access - onError can do async write
+    //TODO: sync access - onError can do async write?
     private Optional onErrorPublisherSubscription = Optional.empty();
 
     private OnErrorResumeProcessor() {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java
new file mode 100644
index 00000000000..f0ff8ec26a2
--- /dev/null
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microprofile.reactive;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+
+import org.reactivestreams.Subscription;
+
+public class TappedSubscription implements Subscription {
+
+    private Optional> onRequest = Optional.empty();
+    private Optional onCancel = Optional.empty();
+
+    private TappedSubscription() {
+    }
+
+    public static TappedSubscription create() {
+        return new TappedSubscription();
+    }
+
+    public TappedSubscription onRequest(Consumer onRequest) {
+        this.onRequest = Optional.of(onRequest);
+        return this;
+    }
+
+    public TappedSubscription onCancel(Runnable onCancel) {
+        this.onCancel = Optional.of(onCancel);
+        return this;
+    }
+
+    @Override
+    public void request(long n) {
+        this.onRequest.ifPresent(c -> c.accept(n));
+    }
+
+    @Override
+    public void cancel() {
+        this.onCancel.ifPresent(Runnable::run);
+    }
+}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index d454241c720..9ab200d1904 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -669,10 +669,8 @@ void coupledCompleteOnCancel() throws InterruptedException, ExecutionException,
                 .fromCompletionStage(new CompletableFuture<>())
                 .via(
                         ReactiveStreams
-                                .coupled(ReactiveStreams.builder()
-                                                .cancel(),
-                                        ReactiveStreams
-                                                .fromCompletionStage(new CompletableFuture<>())
+                                .coupled(ReactiveStreams.builder().cancel(),
+                                        ReactiveStreams.fromCompletionStage(new CompletableFuture<>())
                                                 .onTerminate(() -> {
                                                     publisherCancelled.complete(null);
                                                 }))
diff --git a/microprofile/tests/tck/tck-reactive-operators/pom.xml b/microprofile/tests/tck/tck-reactive-operators/pom.xml
index 666517c6d78..dc9a7c253e4 100644
--- a/microprofile/tests/tck/tck-reactive-operators/pom.xml
+++ b/microprofile/tests/tck/tck-reactive-operators/pom.xml
@@ -44,7 +44,7 @@
         
             io.helidon.microprofile
             helidon-microprofile-reactive-streams
-            1.3.2-SNAPSHOT
+            2.0-SNAPSHOT
         
 
         

From 56254f1c10784b2035ce9b54f4e9df2e1c6c94aa Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 14 Dec 2019 17:51:14 +0100
Subject: [PATCH 50/66] Passing 1221 failing 24/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/RSCompatibleProcessor.java       | 13 ++++--
 .../common/reactive/RecursionUtils.java       | 43 ++++++++++++++++++
 .../common/reactive/RecursionDepthTest.java   | 45 +++++++++++++++++++
 .../microprofile/reactive/OfPublisher.java    | 43 +++++++++++++-----
 4 files changed, 131 insertions(+), 13 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
 create mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index a6c38588a35..c98a407f35d 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -43,13 +43,20 @@ public boolean isRsCompatible() {
 
     @Override
     public void request(long n) {
-        if (rsCompatible && n <= 0) {
-            // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-            fail(new IllegalArgumentException("non-positive subscription request"));
+        if (rsCompatible) {
+            if (n <= 0) {
+                // https://github.com/reactive-streams/reactive-streams-jvm#3.9
+                fail(new IllegalArgumentException("non-positive subscription request"));
+            }
+            if (RecursionUtils.recursionDepthExceeded(5)) {
+                // https://github.com/reactive-streams/reactive-streams-jvm#3.3
+                fail(new IllegalCallerException("Recursion depth exceeded 3.3"));
+            }
         }
         super.request(n);
     }
 
+
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
         if (rsCompatible && !getSubscriber().isClosed() && !buffer.isEmpty()) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java b/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
new file mode 100644
index 00000000000..94bc7ab31f8
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.Objects;
+
+public class RecursionUtils {
+    public static boolean recursionDepthExceeded(int i) {
+        StackTraceElement parentElement = StackWalker.getInstance()
+                .walk(stackFrameStream -> stackFrameStream.skip(1).findFirst())
+                .get()
+                .toStackTraceElement();
+        return StackWalker.getInstance()
+                .walk(ss -> ss
+                        .map(StackWalker.StackFrame::toStackTraceElement)
+                        .filter(el -> equals(el, parentElement))
+                        .count() > i);
+    }
+
+    static boolean equals(StackTraceElement a, StackTraceElement b) {
+        return Objects.equals(a.getClassLoaderName(), b.getClassLoaderName()) &&
+                Objects.equals(a.getModuleName(), b.getModuleName()) &&
+                Objects.equals(a.getModuleVersion(), b.getModuleVersion()) &&
+                Objects.equals(a.getClassName(), b.getClassName()) &&
+                Objects.equals(a.getMethodName(), b.getMethodName());
+
+    }
+}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java
new file mode 100644
index 00000000000..a9d99defb91
--- /dev/null
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class RecursionDepthTest {
+    @Test
+    void depthTest() {
+        assertFalse(RecursionUtils.recursionDepthExceeded(1));
+        recursionMethod(4, new AtomicInteger(5), Assertions::assertTrue);
+        recursionMethod(1, new AtomicInteger(1), Assertions::assertFalse);
+        recursionMethod(10, new AtomicInteger(9), Assertions::assertFalse);
+        recursionMethod(15, new AtomicInteger(20), Assertions::assertTrue);
+    }
+
+    void recursionMethod(int maxDepth, AtomicInteger counter, Consumer runInDepth) {
+        if (counter.decrementAndGet() == 0) {
+            runInDepth.accept(RecursionUtils.recursionDepthExceeded(maxDepth));
+            return;
+        }
+        recursionMethod(maxDepth, counter, runInDepth);
+    }
+}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index 17ed7cdd9e7..dbcaff54a37 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -20,13 +20,18 @@
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
 
 import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.RequestedCounter;
 
 public class OfPublisher implements Flow.Publisher {
     private Iterable iterable;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
     private AtomicBoolean completed = new AtomicBoolean(false);
+    private AtomicBoolean trampolineLock = new AtomicBoolean(false);
+    private final RequestedCounter requestCounter = new RequestedCounter();
+    private final ReentrantLock iterateConcurrentLock = new ReentrantLock();
 
     public OfPublisher(Iterable iterable) {
         this.iterable = iterable;
@@ -46,18 +51,36 @@ public void subscribe(Flow.Subscriber subscriber) {
             public void request(long n) {
                 if (n <= 0) {
                     // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-                    subscriber.onError(new IllegalArgumentException("non-positive subscription request"));
+                    subscriber.onError(new IllegalArgumentException("non-positive subscription request 3.9"));
+                    return;
                 }
-                for (long i = 0; i < n; i++) {
-                    if (iterator.hasNext() && !cancelled.get()) {
-                        Object next = iterator.next();
-                        Objects.requireNonNull(next);
-                        subscriber.onNext(next);
-                    } else {
-                        if (!completed.getAndSet(true)) {
-                            subscriber.onComplete();
+                requestCounter.increment(n, subscriber::onError);
+                trySubmit();
+            }
+
+            private void trySubmit() {
+                if (!trampolineLock.getAndSet(true)) {
+                    try {
+                        while (requestCounter.tryDecrement()) {
+                            iterateConcurrentLock.lock();
+                            if (iterator.hasNext() && !cancelled.get()) {
+                                Object next = iterator.next();
+                                iterateConcurrentLock.unlock();
+                                Objects.requireNonNull(next);
+                                subscriber.onNext(next);
+                            } else {
+                                if (!completed.getAndSet(true)) {
+                                    subscriber.onComplete();
+                                }
+                                iterateConcurrentLock.unlock();
+                                break;
+                            }
+                        }
+                    } finally {
+                        if (iterateConcurrentLock.isHeldByCurrentThread()) {
+                            iterateConcurrentLock.unlock();
                         }
-                        break;
+                        trampolineLock.set(false);
                     }
                 }
             }

From 7a5669ccd77e49d90e546b85dc3055ab7e3e35f6 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 14 Dec 2019 19:17:52 +0100
Subject: [PATCH 51/66] Passing 1226 failing 19/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../io/helidon/common/reactive/BaseProcessor.java  | 14 +++++++-------
 .../common/reactive/RSCompatibleProcessor.java     | 13 ++++++++++++-
 .../microprofile/reactive/ConcatPublisher.java     |  1 +
 .../reactive/OnErrorResumeProcessor.java           |  8 ++------
 4 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 59d195257e8..9e04223e83f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -35,8 +35,8 @@ public abstract class BaseProcessor implements Processor, Subscripti
     private final RequestedCounter requested;
     private final AtomicBoolean ready;
     private final AtomicBoolean subscribed;
-    private volatile boolean done;
-    private Throwable error;
+    protected volatile boolean done;
+    protected Throwable error;
 
     /**
      * Generic processor used for the implementation of {@link Multi} and {@link Single}.
@@ -94,11 +94,6 @@ public void onNext(T item) {
      * @param ex Exception to be reported downstream
      */
     protected void fail(Throwable ex) {
-        onError(ex);
-    }
-
-    @Override
-    public void onError(Throwable ex) {
         done = true;
         if (error == null) {
             error = ex;
@@ -106,6 +101,11 @@ public void onError(Throwable ex) {
         tryComplete();
     }
 
+    @Override
+    public void onError(Throwable ex) {
+        fail(ex);
+    }
+
     @Override
     public void onComplete() {
         done = true;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
index c98a407f35d..e946e906032 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
@@ -21,6 +21,7 @@
 import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.locks.ReentrantLock;
 
 public class RSCompatibleProcessor extends BaseProcessor {
@@ -31,6 +32,7 @@ public class RSCompatibleProcessor extends BaseProcessor {
     private ReferencedSubscriber referencedSubscriber;
     private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
     private ReentrantLock publisherSequentialLock = new ReentrantLock();
+    protected CompletableFuture> subscribedSubscriber = new CompletableFuture<>();
 
 
     public void setRSCompatible(boolean rsCompatible) {
@@ -110,6 +112,7 @@ public void onSubscribe(Flow.Subscription s) {
             // https://github.com/reactive-streams/reactive-streams-jvm#2.5
             getSubscription().ifPresent(firstSubscription -> s.cancel());
             super.onSubscribe(s);
+            subscribedSubscriber.complete(referencedSubscriber);
             publisherSequentialLock.unlock();
         } else {
             super.onSubscribe(s);
@@ -150,11 +153,19 @@ public void fail(Throwable ex) {
 
     @Override
     public void onError(Throwable ex) {
+        superOnError(ex);
+    }
+
+    protected void superOnError(Throwable ex) {
         if (rsCompatible) {
             // https://github.com/reactive-streams/reactive-streams-jvm#2.13
             Objects.requireNonNull(ex);
         }
-        super.onError(ex);
+        done = true;
+        if (error == null) {
+            error = ex;
+        }
+        tryComplete();
     }
 
     public static class ReferencedSubscriber implements Flow.Subscriber {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
index 2accb1c79e1..c2e8b4a5f0e 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
@@ -55,6 +55,7 @@ public void request(long n) {
                 if (n <= 0) {
                     // https://github.com/reactive-streams/reactive-streams-jvm#3.9
                     subscriber.onError(new IllegalArgumentException("non-positive subscription request"));
+                    return;
                 }
                 requested.set(n);
                 if (!firstProcessor.complete) {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 8b6b04ff0b3..80edec4713a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -104,7 +104,7 @@ public void onNext(T t) {
                     @Override
                     public void onError(Throwable t) {
                         Objects.requireNonNull(t);
-                        superError(t);
+                        superOnError(t);
                     }
 
                     @Override
@@ -116,14 +116,10 @@ public void onComplete() {
             }
         } catch (Throwable t) {
             onErrorPublisherSubscription.ifPresent(Subscription::cancel);
-            superError(t);
+            superOnError(t);
         }
     }
 
-    private void superError(Throwable t) {
-        super.onError(t);
-    }
-
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         subscription.cancel();

From 4d323e1b1b166c919ba746c606a6908bab7bbf17 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sun, 15 Dec 2019 21:57:18 +0100
Subject: [PATCH 52/66] Passing 1246 failing 2/1948 MP RS operators tck tests

Signed-off-by: Daniel Kec 
---
 .../reactive/CoupledProcessor.java            | 46 +++++++----
 .../reactive/CumulativeProcessor.java         | 24 ++++--
 .../reactive/ConcatProcessorTest.java         |  1 -
 .../reactive/CoupledProcessorTest.java        | 79 +++++++++++++++++++
 4 files changed, 125 insertions(+), 25 deletions(-)
 create mode 100644 microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java

diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index a8b436fa33f..4a9c7bc9032 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -20,7 +20,9 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
+
+import io.helidon.common.reactive.RecursionUtils;
+import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -29,9 +31,9 @@
 
 public class CoupledProcessor implements Processor {
 
-    private Subscriber passedInSubscriber;
+    private HybridSubscriber passedInSubscriber;
     private Publisher passedInPublisher;
-    private Subscriber outletSubscriber;
+    private HybridSubscriber outletSubscriber;
     private Subscriber inletSubscriber;
     private Subscription inletSubscription;
     private Subscription passedInPublisherSubscription;
@@ -40,15 +42,14 @@ public class CoupledProcessor implements Processor {
 
 
     public CoupledProcessor(Subscriber passedInSubscriber, Publisher passedInPublisher) {
-        this.passedInSubscriber = passedInSubscriber;
+        this.passedInSubscriber = HybridSubscriber.from(passedInSubscriber);
         this.passedInPublisher = passedInPublisher;
         this.inletSubscriber = this;
     }
 
     @Override
     public void subscribe(Subscriber outletSubscriber) {
-
-        this.outletSubscriber = outletSubscriber;
+        this.outletSubscriber = HybridSubscriber.from(outletSubscriber);
         passedInPublisher.subscribe(new Subscriber() {
 
             @Override
@@ -71,11 +72,13 @@ public void onNext(T t) {
 
             @Override
             public void onError(Throwable t) {
+                //Passed in publisher sent onError
                 cancelled.set(true);
                 Objects.requireNonNull(t);
                 outletSubscriber.onError(t);
                 passedInSubscriber.onError(t);
-                inletSubscription.cancel();
+                inletSubscriber.onError(t);
+                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);//TODO: 203
             }
 
             @Override
@@ -84,6 +87,7 @@ public void onComplete() {
                 cancelled.set(true);
                 outletSubscriber.onComplete();
                 passedInSubscriber.onComplete();
+                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);//TODO: 203
             }
         });
 
@@ -91,6 +95,10 @@ public void onComplete() {
 
             @Override
             public void request(long n) {
+                if (RecursionUtils.recursionDepthExceeded(2)) {
+                    // https://github.com/reactive-streams/reactive-streams-jvm#3.3
+                    outletSubscriber.onError(new IllegalCallerException("Recursion depth exceeded 3.3"));
+                }
                 passedInPublisherSubscription.request(n);
             }
 
@@ -98,7 +106,9 @@ public void request(long n) {
             public void cancel() {
                 // Cancel from outlet subscriber
                 passedInSubscriber.onComplete();
-                inletSubscription.cancel();
+                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
+                CoupledProcessor.this.passedInSubscriber.releaseReferences();
+                CoupledProcessor.this.outletSubscriber.releaseReferences();
             }
         });
     }
@@ -115,17 +125,24 @@ public void onSubscribe(Subscription inletSubscription) {
         passedInSubscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
+                if (RecursionUtils.recursionDepthExceeded(5)) {
+                    // https://github.com/reactive-streams/reactive-streams-jvm#3.3
+                    passedInSubscriber.onError(new IllegalCallerException("Recursion depth exceeded 3.3"));
+                }
                 inletSubscription.request(n);
             }
 
             @Override
             public void cancel() {
                 // Cancel from passed in subscriber
-                cancelled.set(true);
+                if (cancelled.getAndSet(true)) {
+                    return;
+                }
                 inletSubscription.cancel();
-                //passedInPublisherSubscription.cancel();//LIVELOCK!!!
                 outletSubscriber.onComplete();
-                CoupledProcessor.this.outletSubscriber = null;
+                passedInPublisherSubscription.cancel();
+                passedInSubscriber.releaseReferences();
+                outletSubscriber.releaseReferences();
             }
         });
     }
@@ -141,18 +158,15 @@ public void onError(Throwable t) {
         cancelled.set(true);
         // Inlet/upstream publisher sent error
         passedInSubscriber.onError(Objects.requireNonNull(t));
-//        outletSubscriber.onError(t);
-        //passedInPublisherSubscription.cancel();
+        outletSubscriber.onError(t);
+        passedInPublisherSubscription.cancel();
     }
 
     @Override
     public void onComplete() {
         // Inlet/upstream publisher completed
         cancelled.set(true);
-//        passedInPublisherSubscription.cancel();
-//        passedInSubscriber.onSubscribe(TappedSubscription.create());
         passedInSubscriber.onComplete();
-//        outletSubscriber.onSubscribe(TappedSubscription.create());
         outletSubscriber.onComplete();
         passedInPublisherSubscription.cancel();
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index 8cf2a76df25..584680f5c90 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -20,6 +20,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
@@ -34,6 +35,7 @@
 public class CumulativeProcessor implements Processor {
     private LinkedList> processorList = new LinkedList<>();
     private Subscription subscription;
+    private AtomicBoolean chainConnected = new AtomicBoolean(false);
 
     /**
      * Create {@link org.reactivestreams.Processor} wrapping ordered list of {@link io.helidon.common.reactive.Flow.Processor}s.
@@ -50,9 +52,9 @@ public class CumulativeProcessor implements Processor {
     @Override
     public void subscribe(Subscriber s) {
         processorList.getLast().subscribe(s);
+        tryChainSubscribe();
     }
 
-
     @Override
     public void onSubscribe(Subscription subscription) {
         Objects.requireNonNull(subscription);
@@ -61,15 +63,21 @@ public void onSubscribe(Subscription subscription) {
             return;
         }
         this.subscription = subscription;
-        // This is the time for connecting all processors
-        Processor lastProcessor = null;
-        for (Processor processor : processorList) {
-            if (lastProcessor != null) {
-                lastProcessor.subscribe(processor);
+        tryChainSubscribe();
+        processorList.getFirst().onSubscribe(subscription);
+    }
+
+    private void tryChainSubscribe() {
+        if (!chainConnected.getAndSet(true)) {
+            // This is the time for connecting all processors
+            Processor lastProcessor = null;
+            for (Processor processor : processorList) {
+                if (lastProcessor != null) {
+                    lastProcessor.subscribe(processor);
+                }
+                lastProcessor = processor;
             }
-            lastProcessor = processor;
         }
-        processorList.getFirst().onSubscribe(subscription);
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java
index 4eea0677e01..e9a79bdddcb 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/ConcatProcessorTest.java
@@ -28,7 +28,6 @@ public class ConcatProcessorTest extends AbstractProcessorTest {
 
     @Override
     protected Publisher getPublisher(long items) {
-        ;
         return ReactiveStreams.concat(
                 ReactiveStreams.fromIterable(LongStream.range(0, items / 2).boxed().collect(Collectors.toList())),
                 ReactiveStreams.fromIterable(LongStream.range(items / 2, items).boxed().collect(Collectors.toList()))
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
new file mode 100644
index 00000000000..1013890dc62
--- /dev/null
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.microrofile.reactive;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.LongStream;
+
+import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
+import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+
+public class CoupledProcessorTest extends AbstractProcessorTest {
+
+    @Override
+    protected Publisher getPublisher(long items) {
+        return ReactiveStreams.coupled(ReactiveStreams.builder().ignore(), ReactiveStreams.fromIterable(
+                () -> LongStream.rangeClosed(1, items).boxed().iterator()
+        )).buildRs();
+    }
+
+    @Override
+    protected Processor getFailedProcessor(RuntimeException t) {
+        return ReactiveStreams.coupled(
+                ReactiveStreams.builder().ignore(),
+                ReactiveStreams.failed(new TestRuntimeException()))
+                .buildRs();
+    }
+
+    @Test
+    void coupledProcessorAsProcessor() throws InterruptedException, ExecutionException, TimeoutException {
+        ProcessorBuilder processorBuilder = ReactiveStreams.coupled(ReactiveStreams.builder().ignore(), ReactiveStreams.fromIterable(
+                () -> LongStream.rangeClosed(1, 5).boxed().iterator()
+        ));
+
+        List result = ReactiveStreams.of(3L, 2L, 3L)
+                .via(processorBuilder)
+                .toList().run().toCompletableFuture().get(1, TimeUnit.SECONDS);
+
+        System.out.println(result);
+    }
+
+    @Test
+    void coupledProcessorAsPublisher() throws InterruptedException, ExecutionException, TimeoutException {
+        Processor processor = ReactiveStreams
+                .coupled(
+                        ReactiveStreams.builder().ignore(),
+                        ReactiveStreams.fromIterable(() -> LongStream.rangeClosed(1, 3).boxed().iterator())
+                )
+                .buildRs();
+
+        List result = ReactiveStreams.fromPublisher(processor)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+
+        System.out.println(result);
+    }
+}

From ff02bf343bb93efb5e552b5f8a273629daa899c0 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Thu, 19 Dec 2019 15:48:09 +0100
Subject: [PATCH 53/66] Clean up, Coupled deadlock fix, FlatMap lost last item
 fix

Signed-off-by: Daniel Kec 
---
 ...eProcessor.java => BufferedProcessor.java} | 115 +++++---------
 .../common/reactive/DistinctProcessor.java    |   2 +-
 .../common/reactive/DropWhileProcessor.java   |   2 +-
 .../common/reactive/FilterProcessor.java      |   2 +-
 .../common/reactive/LimitProcessor.java       |   2 +-
 .../reactive/MultiMappingProcessor.java       |   2 +-
 .../common/reactive/PeekProcessor.java        |   2 +-
 .../common/reactive/RecursionUtils.java       |  43 -----
 .../common/reactive/RequestedCounter.java     |   3 +-
 .../common/reactive/SkipProcessor.java        |   2 +-
 .../reactive/StreamValidationUtils.java       | 103 ++++++++++++
 .../common/reactive/TakeWhileProcessor.java   |   2 +-
 .../common/reactive/RecursionDepthTest.java   |   4 +-
 .../reactive/CoupledProcessor.java            |  46 ++++--
 .../reactive/FlatMapProcessor.java            |  17 +-
 .../microprofile/reactive/GraphBuilder.java   |   7 +-
 .../microprofile/reactive/MapProcessor.java   |   4 +-
 .../microprofile/reactive/OfPublisher.java    |   5 -
 .../reactive/OnErrorResumeProcessor.java      |   4 +-
 .../reactive/TappedProcessor.java             |   5 +-
 .../reactive/AbstractProcessorTest.java       |   6 +-
 .../reactive/CoupledProcessorTest.java        | 147 ++++++++++++++++++
 .../FlatMapIterableProcessorTest.java         |   4 +-
 .../reactive/OnErrorResumeProcessorTest.java  |   5 +-
 .../tests/tck/tck-reactive-operators/pom.xml  |   2 +-
 ...ava => HelidonReactiveStreamsTckTest.java} |   4 +-
 26 files changed, 362 insertions(+), 178 deletions(-)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{RSCompatibleProcessor.java => BufferedProcessor.java} (53%)
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
 rename microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/{HelidonStreamEngineTckTest.java => HelidonReactiveStreamsTckTest.java} (87%)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
similarity index 53%
rename from common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index e946e906032..c4fb2cfd3d8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RSCompatibleProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -21,47 +21,28 @@
 import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.locks.ReentrantLock;
 
-public class RSCompatibleProcessor extends BaseProcessor {
+public class BufferedProcessor extends BaseProcessor {
 
     private static final int BACK_PRESSURE_BUFFER_SIZE = 1024;
 
-    private boolean rsCompatible = false;
     private ReferencedSubscriber referencedSubscriber;
     private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
     private ReentrantLock publisherSequentialLock = new ReentrantLock();
-    protected CompletableFuture> subscribedSubscriber = new CompletableFuture<>();
-
-
-    public void setRSCompatible(boolean rsCompatible) {
-        this.rsCompatible = rsCompatible;
-    }
-
-    public boolean isRsCompatible() {
-        return rsCompatible;
-    }
 
     @Override
     public void request(long n) {
-        if (rsCompatible) {
-            if (n <= 0) {
-                // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-                fail(new IllegalArgumentException("non-positive subscription request"));
-            }
-            if (RecursionUtils.recursionDepthExceeded(5)) {
-                // https://github.com/reactive-streams/reactive-streams-jvm#3.3
-                fail(new IllegalCallerException("Recursion depth exceeded 3.3"));
-            }
-        }
+        //TODO: Move to BaseProcessor
+        StreamValidationUtils.checkRequestParam309(n, this::fail);
+        StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> fail(t));
         super.request(n);
     }
 
 
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
-        if (rsCompatible && !getSubscriber().isClosed() && !buffer.isEmpty()) {
+        if (true && !getSubscriber().isClosed() && !buffer.isEmpty()) {
             try {
                 submit(buffer.take());
             } catch (InterruptedException e) {
@@ -74,67 +55,54 @@ protected void tryRequest(Flow.Subscription subscription) {
 
     @Override
     public void subscribe(Flow.Subscriber s) {
+        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
+        //TODO: Move to BaseProcessor
         referencedSubscriber = ReferencedSubscriber.create(s);
         super.subscribe(referencedSubscriber);
     }
 
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
-        if (rsCompatible) {
-            Optional.ofNullable(subscription).ifPresent(Flow.Subscription::cancel);
-            referencedSubscriber.releaseReference();
-        }
+        //TODO: Move to BaseProcessor
+        Optional.ofNullable(subscription).ifPresent(Flow.Subscription::cancel);
+        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
+        referencedSubscriber.releaseReference();
     }
 
     @Override
     public void onNext(T item) {
-        if (rsCompatible) {
-            publisherSequentialLock.lock();
-            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-            Objects.requireNonNull(item);
-            try {
-                hookOnNext(item);
-            } catch (Throwable ex) {
-                fail(ex);
-            }
-            publisherSequentialLock.unlock();
-        } else {
-            super.onNext(item);
-        }
+        //TODO: Move to BaseProcessor
+        publisherSequentialLock.lock();
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+        Objects.requireNonNull(item);
+        try {
+            hookOnNext(item);
+        } catch (Throwable ex) {
+            fail(ex);
+        }
+        publisherSequentialLock.unlock();
     }
 
     @Override
+    //TODO: Move to BaseProcessor
     public void onSubscribe(Flow.Subscription s) {
-        if (rsCompatible) {
-            publisherSequentialLock.lock();
-            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-            Objects.requireNonNull(s);
-            // https://github.com/reactive-streams/reactive-streams-jvm#2.5
-            getSubscription().ifPresent(firstSubscription -> s.cancel());
-            super.onSubscribe(s);
-            subscribedSubscriber.complete(referencedSubscriber);
-            publisherSequentialLock.unlock();
-        } else {
-            super.onSubscribe(s);
-        }
+        // https://github.com/reactive-streams/reactive-streams-jvm#1.3
+        publisherSequentialLock.lock();
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+        Objects.requireNonNull(s);
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+        getSubscription().ifPresent(firstSubscription -> s.cancel());
+        super.onSubscribe(s);
+        publisherSequentialLock.unlock();
     }
 
     @Override
     protected void notEnoughRequest(U item) {
-        if (rsCompatible) {
-            if (!buffer.offer(item)) {
-                fail(new BackPressureOverflowException(BACK_PRESSURE_BUFFER_SIZE));
-            }
-        } else {
-            super.notEnoughRequest(item);
+        if (!buffer.offer(item)) {
+            fail(new BackPressureOverflowException(BACK_PRESSURE_BUFFER_SIZE));
         }
     }
 
-    @Override
-    protected void submit(U item) {
-        super.submit(item);
-    }
-
     @Override
     public void onComplete() {
         if (buffer.isEmpty()) {
@@ -143,24 +111,23 @@ public void onComplete() {
     }
 
     @Override
+    //TODO: Move to BaseProcessor
     public void fail(Throwable ex) {
-        if (rsCompatible) {
-            //Upstream cancel on error with fail method proxy to avoid spec rule 2.3
-            getSubscription().ifPresent(Flow.Subscription::cancel);
-        }
+        //Upstream cancel on error with fail method proxy to avoid spec rule 2.3
+        getSubscription().ifPresent(Flow.Subscription::cancel);
         super.fail(ex);
     }
 
     @Override
+    //TODO: Move to BaseProcessor
     public void onError(Throwable ex) {
         superOnError(ex);
     }
 
+    //TODO: Move to BaseProcessor
     protected void superOnError(Throwable ex) {
-        if (rsCompatible) {
-            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-            Objects.requireNonNull(ex);
-        }
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+        Objects.requireNonNull(ex);
         done = true;
         if (error == null) {
             error = ex;
@@ -168,9 +135,9 @@ protected void superOnError(Throwable ex) {
         tryComplete();
     }
 
-    public static class ReferencedSubscriber implements Flow.Subscriber {
+    private static class ReferencedSubscriber implements Flow.Subscriber {
 
-        private Optional> subscriber = Optional.empty();
+        private Optional> subscriber;
 
         private ReferencedSubscriber(Flow.Subscriber subscriber) {
             this.subscriber = Optional.of(subscriber);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
index 2a33dcf5376..4cff7af9942 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.HashSet;
 
-public class DistinctProcessor extends RSCompatibleProcessor implements Multi {
+public class DistinctProcessor extends BufferedProcessor implements Multi {
     private final HashSet distinctSet;
 
     public DistinctProcessor() {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
index 057e389459a..3ec9eb15392 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class DropWhileProcessor extends RSCompatibleProcessor implements Multi {
+public class DropWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
     private boolean foundNotMatching = false;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
index 760e0fb323b..1777f6eb582 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class FilterProcessor extends RSCompatibleProcessor implements Multi {
+public class FilterProcessor extends BufferedProcessor implements Multi {
 
     private Predicate predicate;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index b06173be181..fa6d6a135e2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class LimitProcessor extends RSCompatibleProcessor implements Multi {
+public class LimitProcessor extends BufferedProcessor implements Multi {
 
     private final AtomicLong counter;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
index 81e5722c8b1..0d0aa750bb3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
@@ -26,7 +26,7 @@
  * @param  subscribed type
  * @param  published type
  */
-public final class MultiMappingProcessor extends RSCompatibleProcessor implements Multi {
+public final class MultiMappingProcessor extends BufferedProcessor implements Multi {
 
     private final Mapper mapper;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
index def5e42c7d7..d2d24a67a2c 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class PeekProcessor extends RSCompatibleProcessor implements Multi {
+public class PeekProcessor extends BufferedProcessor implements Multi {
 
     private Consumer consumer;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java b/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
deleted file mode 100644
index 94bc7ab31f8..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RecursionUtils.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive;
-
-import java.util.Objects;
-
-public class RecursionUtils {
-    public static boolean recursionDepthExceeded(int i) {
-        StackTraceElement parentElement = StackWalker.getInstance()
-                .walk(stackFrameStream -> stackFrameStream.skip(1).findFirst())
-                .get()
-                .toStackTraceElement();
-        return StackWalker.getInstance()
-                .walk(ss -> ss
-                        .map(StackWalker.StackFrame::toStackTraceElement)
-                        .filter(el -> equals(el, parentElement))
-                        .count() > i);
-    }
-
-    static boolean equals(StackTraceElement a, StackTraceElement b) {
-        return Objects.equals(a.getClassLoaderName(), b.getClassLoaderName()) &&
-                Objects.equals(a.getModuleName(), b.getModuleName()) &&
-                Objects.equals(a.getModuleVersion(), b.getModuleVersion()) &&
-                Objects.equals(a.getClassName(), b.getClassName()) &&
-                Objects.equals(a.getMethodName(), b.getMethodName());
-
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java b/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
index 6d602e8052a..0734f7f4d18 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
@@ -37,8 +37,7 @@ public class RequestedCounter {
      * process errors
      */
     public void increment(long increment, Consumer errorHandler) {
-        if (increment <= 0) {
-            errorHandler.accept(new IllegalArgumentException("Unsupported requested event increment: " + increment));
+        if (!StreamValidationUtils.checkRequestParam309(increment, errorHandler)) {
             return;
         }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
index a025377dd77..e9f43954598 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-public class SkipProcessor extends RSCompatibleProcessor implements Multi {
+public class SkipProcessor extends BufferedProcessor implements Multi {
 
     private final AtomicLong counter;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java b/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
new file mode 100644
index 00000000000..471a1cb5e42
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+/**
+ * Helper methods for stream validation.
+ */
+public class StreamValidationUtils {
+
+    private StreamValidationUtils() {
+    }
+
+    /**
+     * Validation of Reactive Streams Specification for JVM rule 3.3.
+     * 
    
+     * {@code Subscription.request} MUST place an upper bound on possible synchronous
+     * recursion between {@code Publisher} and {@code Subscriber}.
+     *
+     * @param maxDepth   maximal expected recursion depth
+     * @param onExceeded called if recursion is deeper than maxDepth,
+     *                   provided with actual depth and spec compliant exception.
+     * @param         payload type of the subscriber
+     * @return true if valid
+     * @see reactive-streams/reactive-streams-jvm#3.3
+     */
+    public static  boolean checkRecursionDepth303(int maxDepth, BiConsumer onExceeded) {
+        Long recursionDepth = getRecursionDepth();
+        if (recursionDepth > maxDepth) {
+            Optional.of(onExceeded)
+                    .ifPresent(onExc -> onExc
+                            .accept(recursionDepth, new IllegalCallerException(String
+                                    .format("Recursion depth exceeded, max depth expected %d but actual is %d, rule 3.3",
+                                            maxDepth, recursionDepth))));
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Validation of Reactive Streams Specification for JVM rule 3.9.
+     * 
    
+     * While the {@code Subscription} is not cancelled, {@code Subscription.request(long n)}
+     * MUST signal onError with a {@link java.lang.IllegalArgumentException} if the argument is <= 0.
+     * The cause message SHOULD explain that non-positive request signals are illegal.
+     *
+     * @param requestParam number of requested items to be validated.
+     * @param onExceeded   called if request param invalid provided with spec compliant exception.
+     * @return true if requested parameter is valid
+     * @see reactive-streams/reactive-streams-jvm#3.9
+     */
+    public static boolean checkRequestParam309(long requestParam, Consumer onExceeded) {
+        if (requestParam <= 0) {
+            Optional.of(onExceeded)
+                    .ifPresent(onExc -> onExc
+                            .accept(new IllegalArgumentException(String
+                                    .format("Non-positive subscription request %d, rule 3.9", requestParam))));
+            return false;
+        }
+        return true;
+    }
+
+
+    static Long getRecursionDepth() {
+        StackTraceElement parentElement = StackWalker.getInstance()
+                .walk(stackFrameStream -> stackFrameStream.skip(1).findFirst())
+                .get()
+                .toStackTraceElement();
+        return StackWalker.getInstance()
+                .walk(ss -> ss
+                        .map(StackWalker.StackFrame::toStackTraceElement)
+                        .filter(el -> stackTraceElementEquals(el, parentElement))
+                        .count());
+    }
+
+    static boolean stackTraceElementEquals(StackTraceElement a, StackTraceElement b) {
+        return Objects.equals(a.getClassLoaderName(), b.getClassLoaderName())
+                && Objects.equals(a.getModuleName(), b.getModuleName())
+                && Objects.equals(a.getModuleVersion(), b.getModuleVersion())
+                && Objects.equals(a.getClassName(), b.getClassName())
+                && Objects.equals(a.getMethodName(), b.getMethodName());
+
+    }
+}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 84b7f1e4aab..2f053e339bb 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -19,7 +19,7 @@
 
 import java.util.function.Predicate;
 
-public class TakeWhileProcessor extends RSCompatibleProcessor implements Multi {
+public class TakeWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
     public TakeWhileProcessor(Predicate predicate) {
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java
index a9d99defb91..66eaaebe3cc 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/RecursionDepthTest.java
@@ -28,7 +28,7 @@
 public class RecursionDepthTest {
     @Test
     void depthTest() {
-        assertFalse(RecursionUtils.recursionDepthExceeded(1));
+        assertFalse(StreamValidationUtils.getRecursionDepth() > 1);
         recursionMethod(4, new AtomicInteger(5), Assertions::assertTrue);
         recursionMethod(1, new AtomicInteger(1), Assertions::assertFalse);
         recursionMethod(10, new AtomicInteger(9), Assertions::assertFalse);
@@ -37,7 +37,7 @@ void depthTest() {
 
     void recursionMethod(int maxDepth, AtomicInteger counter, Consumer runInDepth) {
         if (counter.decrementAndGet() == 0) {
-            runInDepth.accept(RecursionUtils.recursionDepthExceeded(maxDepth));
+            runInDepth.accept(StreamValidationUtils.getRecursionDepth() > maxDepth);
             return;
         }
         recursionMethod(maxDepth, counter, runInDepth);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
index 4a9c7bc9032..52ebc82f20a 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
@@ -21,7 +21,7 @@
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import io.helidon.common.reactive.RecursionUtils;
+import io.helidon.common.reactive.StreamValidationUtils;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.reactivestreams.Processor;
@@ -29,6 +29,26 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
+/**
+ * Coupled processor sends all upstream.
+ * 
    + *     +
+ *     |  Inlet/upstream publisher
+ * +-------+
+ * |   |   |   passed in subscriber
+ * |   +-------------------------->
+ * |       |   passed in publisher
+ * |   +--------------------------+
+ * |   |   |
+ * +-------+
+ *     |  Outlet/downstream subscriber
+ *     v
+ * 
    
+ *
+ * @param 
+ * @param 
+ * @see org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams#coupled(org.reactivestreams.Subscriber, org.reactivestreams.Publisher)
+ */
 public class CoupledProcessor implements Processor {
 
     private HybridSubscriber passedInSubscriber;
@@ -54,6 +74,7 @@ public void subscribe(Subscriber outletSubscriber) {
 
             @Override
             public void onSubscribe(Subscription passedInPublisherSubscription) {
+                //Passed in publisher called onSubscribed
                 Objects.requireNonNull(passedInPublisherSubscription);
                 // https://github.com/reactive-streams/reactive-streams-jvm#2.5
                 if (Objects.nonNull(CoupledProcessor.this.passedInPublisherSubscription) || cancelled.get()) {
@@ -66,6 +87,7 @@ public void onSubscribe(Subscription passedInPublisherSubscription) {
             @Override
             @SuppressWarnings("unchecked")
             public void onNext(T t) {
+                //Passed in publisher sent onNext
                 Objects.requireNonNull(t);
                 outletSubscriber.onNext((R) t);
             }
@@ -78,7 +100,8 @@ public void onError(Throwable t) {
                 outletSubscriber.onError(t);
                 passedInSubscriber.onError(t);
                 inletSubscriber.onError(t);
-                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);//TODO: 203
+                //203 https://github.com/eclipse/microprofile-reactive-streams-operators/issues/131
+                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
             }
 
             @Override
@@ -87,7 +110,8 @@ public void onComplete() {
                 cancelled.set(true);
                 outletSubscriber.onComplete();
                 passedInSubscriber.onComplete();
-                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);//TODO: 203
+                //203 https://github.com/eclipse/microprofile-reactive-streams-operators/issues/131
+                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
             }
         });
 
@@ -95,10 +119,8 @@ public void onComplete() {
 
             @Override
             public void request(long n) {
-                if (RecursionUtils.recursionDepthExceeded(2)) {
-                    // https://github.com/reactive-streams/reactive-streams-jvm#3.3
-                    outletSubscriber.onError(new IllegalCallerException("Recursion depth exceeded 3.3"));
-                }
+                // Request from outlet subscriber
+                StreamValidationUtils.checkRecursionDepth303(2, (actDepth, t) -> outletSubscriber.onError(t));
                 passedInPublisherSubscription.request(n);
             }
 
@@ -107,6 +129,7 @@ public void cancel() {
                 // Cancel from outlet subscriber
                 passedInSubscriber.onComplete();
                 Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
+                passedInPublisherSubscription.cancel();
                 CoupledProcessor.this.passedInSubscriber.releaseReferences();
                 CoupledProcessor.this.outletSubscriber.releaseReferences();
             }
@@ -125,10 +148,7 @@ public void onSubscribe(Subscription inletSubscription) {
         passedInSubscriber.onSubscribe(new Subscription() {
             @Override
             public void request(long n) {
-                if (RecursionUtils.recursionDepthExceeded(5)) {
-                    // https://github.com/reactive-streams/reactive-streams-jvm#3.3
-                    passedInSubscriber.onError(new IllegalCallerException("Recursion depth exceeded 3.3"));
-                }
+                StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> passedInSubscriber.onError(t));
                 inletSubscription.request(n);
             }
 
@@ -148,15 +168,15 @@ public void cancel() {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
     public void onNext(T t) {
+        // Inlet/upstream publisher sent onNext
         passedInSubscriber.onNext(Objects.requireNonNull(t));
     }
 
     @Override
     public void onError(Throwable t) {
-        cancelled.set(true);
         // Inlet/upstream publisher sent error
+        cancelled.set(true);
         passedInSubscriber.onError(Objects.requireNonNull(t));
         outletSubscriber.onError(t);
         passedInPublisherSubscription.cancel();
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
index a2f0560199a..4924552b758 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
@@ -22,9 +22,9 @@
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
 
+import io.helidon.common.reactive.RequestedCounter;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
@@ -42,7 +42,7 @@ public class FlatMapProcessor implements Processor {
     private Function mapper;
     private HybridSubscriber subscriber;
     private Subscription subscription;
-    private final AtomicLong requestCounter = new AtomicLong();
+    private RequestedCounter requestCounter = new RequestedCounter();
     private Subscription innerSubscription;
     private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
 
@@ -73,12 +73,7 @@ static FlatMapProcessor fromPublisherMapper(Function mapper) {
     private class FlatMapSubscription implements Subscription {
         @Override
         public void request(long n) {
-            //TODO: Create some kind of reusable request counter
-            try {
-                requestCounter.set(Math.addExact(requestCounter.get(), n));
-            } catch (ArithmeticException e) {
-                requestCounter.set(Long.MAX_VALUE);
-            }
+            requestCounter.increment(n, FlatMapProcessor.this::onError);
 
             if (buffer.isComplete() || Objects.isNull(innerSubscription)) {
                 subscription.request(requestCounter.get());
@@ -153,7 +148,6 @@ public void tryNext() {
             Object nextItem = buffer.poll();
             if (Objects.nonNull(nextItem)) {
                 lastSubscriber = executeMapper(nextItem);
-                lastSubscriber.whenComplete(this::tryNext);
             } else if (onCompleteReceivedAlready.get()) {
                 // Received onComplete and all Publishers are done
                 subscriber.onComplete();
@@ -163,7 +157,6 @@ public void tryNext() {
         public void offer(Object o) {
             if (buffer.isEmpty() && (Objects.isNull(lastSubscriber) || lastSubscriber.isDone())) {
                 lastSubscriber = executeMapper(o);
-                lastSubscriber.whenComplete(this::tryNext);
             } else {
                 buffer.offer(o);
             }
@@ -173,6 +166,7 @@ public InnerSubscriber executeMapper(Object item) {
             InnerSubscriber innerSubscriber = null;
             try {
                 innerSubscriber = new InnerSubscriber();
+                innerSubscriber.whenComplete(this::tryNext);
                 mapper.apply(item).subscribe(innerSubscriber);
             } catch (Throwable t) {
                 subscription.cancel();
@@ -208,7 +202,8 @@ public void onSubscribe(Subscription innerSubscription) {
         public void onNext(Object o) {
             Objects.requireNonNull(o);
             FlatMapProcessor.this.subscriber.onNext(o);
-            long requestCount = requestCounter.decrementAndGet();
+            requestCounter.tryDecrement();
+            long requestCount = requestCounter.get();
             if (requestCount > 0) {
                 innerSubscription.request(requestCount);
             }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index d4710be9afe..c77d22d0a4c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -32,7 +32,7 @@
 import io.helidon.common.reactive.LimitProcessor;
 import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.BufferedProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
@@ -176,9 +176,8 @@ private void addProcessor(Processor processor) {
     }
 
     @SuppressWarnings("unchecked")
-    private  void addProcessor(RSCompatibleProcessor processor) {
-        processor.setRSCompatible(true);
-        processorList.add(HybridProcessor.from((RSCompatibleProcessor) processor));
+    private  void addProcessor(BufferedProcessor processor) {
+        processorList.add(HybridProcessor.from((BufferedProcessor) processor));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
index dc3162488d0..a0af9323ea9 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
@@ -19,7 +19,7 @@
 
 import io.helidon.common.mapper.Mapper;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.BufferedProcessor;
 
 /**
  * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
@@ -27,7 +27,7 @@
  * @param  subscribed type
  * @param  published type
  */
-public final class MapProcessor extends RSCompatibleProcessor {
+public final class MapProcessor extends BufferedProcessor {
 
     private final Mapper mapper;
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
index dbcaff54a37..85cfaefe93c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
@@ -49,11 +49,6 @@ public void subscribe(Flow.Subscriber subscriber) {
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
-                if (n <= 0) {
-                    // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-                    subscriber.onError(new IllegalArgumentException("non-positive subscription request 3.9"));
-                    return;
-                }
                 requestCounter.increment(n, subscriber::onError);
                 trySubmit();
             }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
index 80edec4713a..ccfefd47979 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
@@ -23,7 +23,7 @@
 import java.util.function.Function;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.BufferedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscription;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
@@ -31,7 +31,7 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
-public class OnErrorResumeProcessor extends RSCompatibleProcessor {
+public class OnErrorResumeProcessor extends BufferedProcessor {
 
 
     private AtomicBoolean completed = new AtomicBoolean(false);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
index 7d3114d829d..01be11aac88 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
@@ -22,9 +22,9 @@
 import java.util.function.Function;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.RSCompatibleProcessor;
+import io.helidon.common.reactive.BufferedProcessor;
 
-public class TappedProcessor extends RSCompatibleProcessor {
+public class TappedProcessor extends BufferedProcessor {
 
     private Optional> onNextFunction = Optional.empty();
     private Optional> onErrorConsumer = Optional.empty();
@@ -36,7 +36,6 @@ private TappedProcessor() {
 
     public static TappedProcessor create() {
         TappedProcessor processor = new TappedProcessor();
-        processor.setRSCompatible(true);
         return processor;
     }
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index 83274448383..d55ac370d57 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -145,15 +145,15 @@ void requestCountProcessorTest() {
         testProcessor(ReactiveStreams.fromPublisher(getPublisher(1_000_400L)).via(getProcessor()).buildRs(), s -> {
             s.request(15);
             s.expectRequestCount(15);
-            s.request(2);
-            s.expectRequestCount(17);
+            s.request(3);
+            s.expectRequestCount(18);
         });
     }
 
     @Test
     void longOverFlow() {
         testProcessor(ReactiveStreams.fromPublisher(getPublisher(1_000_400L)).via(getProcessor()).buildRs(), s -> {
-            s.cancelAfter(1_000_000L);
+            s.cancelAfter(1_000_0L);
             s.request(Long.MAX_VALUE - 1);
             s.request(Long.MAX_VALUE - 1);
         });
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
index 1013890dc62..bad4f6ce459 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
@@ -18,16 +18,29 @@
 package io.helidon.microrofile.reactive;
 
 import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.LongStream;
 
+import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
+
 import org.eclipse.microprofile.reactive.streams.operators.ProcessorBuilder;
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
 
 public class CoupledProcessorTest extends AbstractProcessorTest {
 
@@ -76,4 +89,138 @@ void coupledProcessorAsPublisher() throws InterruptedException, ExecutionExcepti
 
         System.out.println(result);
     }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void spec317() throws InterruptedException, ExecutionException, TimeoutException {
+
+        MockPublisher mp = new MockPublisher();
+        Processor sub = new Processor() {
+
+            private Optional subscription = Optional.empty();
+            AtomicInteger counter = new AtomicInteger(10);
+
+            @Override
+            public void onSubscribe(Subscription subscription) {
+                this.subscription = Optional.of(subscription);
+            }
+
+            @Override
+            public void subscribe(Subscriber s) {
+                //mock request
+                System.out.println("Requesting " + 1 + " counter: " + counter.get());
+                subscription.get().request(1);
+            }
+
+            @Override
+            public void onNext(Long o) {
+                subscription.ifPresent(s -> {
+                    if (counter.getAndDecrement() > 0) {
+                        System.out.println("Requesting " + (Long.MAX_VALUE - 1) + " counter: " + counter.get());
+                        s.request(Long.MAX_VALUE - 1);
+                    } else {
+                        s.cancel();
+                    }
+                });
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                fail(t);
+            }
+
+            @Override
+            public void onComplete() {
+
+            }
+        };
+        HybridProcessor tappedProcessor = HybridProcessor.from(TappedProcessor.create());
+
+        Processor processor = ReactiveStreams
+                .coupled(
+                        tappedProcessor,
+                        tappedProcessor
+                )
+                .buildRs();
+
+        CompletionStage completionStage = ReactiveStreams
+                .fromPublisher(new IntSequencePublisher())
+                .map(Long::valueOf)
+                .via(processor)
+                .to(sub)
+                .run();
+
+        //signal request 1 to kickoff overflow simulation
+        sub.subscribe(null);
+
+        //is cancelled afe
+        assertThrows(CancellationException.class, () -> completionStage.toCompletableFuture().get(3, TimeUnit.SECONDS));
+    }
+
+    @Test
+    void spec203() throws InterruptedException, ExecutionException, TimeoutException {
+
+        Processor processor = ReactiveStreams
+                .coupled(
+                        ReactiveStreams.builder().ignore(),
+                        ReactiveStreams.fromPublisher(new Publisher() {
+                            @Override
+                            public void subscribe(Subscriber s) {
+                                s.onSubscribe(new Subscription() {
+                                    @Override
+                                    public void request(long n) {
+                                        System.out.println("Request called");
+                                        s.onNext(4L);
+                                    }
+
+                                    @Override
+                                    public void cancel() {
+                                        System.out.println("Cancel called");
+                                        Throwable thr = new Throwable();
+                                        for (StackTraceElement stackElem : thr.getStackTrace()) {
+                                            if (stackElem.getMethodName().equals("onError")) {
+                                                System.out.println(String.format("Subscription::cancel MUST NOT be called from Subscriber::onError (Rule 2.3)! (Caller: %s::%s line %d)",
+                                                        stackElem.getClassName(), stackElem.getMethodName(), stackElem.getLineNumber()));
+                                            }
+                                        }
+                                    }
+                                });
+                                s.onComplete();
+                            }
+                        })
+                )
+                .buildRs();
+
+        List result = ReactiveStreams
+                .of(1L, 2L)
+                .peek(l -> {
+                    throw new TestRuntimeException();
+                })
+                .via(processor)
+                .toList()
+                .run()
+                .toCompletableFuture()
+                .get(1, TimeUnit.SECONDS);
+
+        System.out.println(result);
+    }
+
+    String ctx = "Wheee ctx";
+
+    @Test
+    void name() {
+        CompletableFuture test = new CompletableFuture<>();
+
+        testMethod1(test);
+        testMethod2(test);
+
+    }
+
+    private void testMethod1(CompletableFuture test) {
+        test.complete(Thread.currentThread().getStackTrace()[2].getMethodName());
+    }
+
+    private void testMethod2(CompletableFuture test) {
+        test.thenAccept(x -> System.out.println(x + ctx));
+    }
 }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
index 478ed25dc18..8a296fe3689 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FlatMapIterableProcessorTest.java
@@ -17,7 +17,7 @@
 
 package io.helidon.microrofile.reactive;
 
-import java.util.Collections;
+import java.util.List;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Processor;
@@ -25,7 +25,7 @@
 public class FlatMapIterableProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
-        return ReactiveStreams.builder().flatMapIterable(Collections::singleton).buildRs();
+        return ReactiveStreams.builder().flatMapIterable(aLong -> List.of(aLong)).buildRs();
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
index 8310c32b44f..9806386b1e5 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
@@ -32,7 +32,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
@@ -100,12 +99,16 @@ protected Processor getProcessor() {
     @Override
     protected Processor getFailedProcessor(RuntimeException t) {
         return ReactiveStreams.builder()
+                .peek(aLong -> {
+                    throw new RuntimeException();
+                })
                 .onErrorResumeWith(throwable -> {
                     throw new TestRuntimeException();
                 })
                 .buildRs();
     }
 
+
     @Test
     void requestCount() {
         Publisher pub = ReactiveStreams.failed(new TestThrowable())
diff --git a/microprofile/tests/tck/tck-reactive-operators/pom.xml b/microprofile/tests/tck/tck-reactive-operators/pom.xml
index dc9a7c253e4..e198096c545 100644
--- a/microprofile/tests/tck/tck-reactive-operators/pom.xml
+++ b/microprofile/tests/tck/tck-reactive-operators/pom.xml
@@ -50,7 +50,7 @@
         
             org.eclipse.microprofile.reactive-streams-operators
             microprofile-reactive-streams-operators-tck
-            1.0
+            1.0.1
         
     
 
diff --git a/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonReactiveStreamsTckTest.java
similarity index 87%
rename from microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
rename to microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonReactiveStreamsTckTest.java
index 520d01fabb3..aadac8e8e47 100644
--- a/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonStreamEngineTckTest.java
+++ b/microprofile/tests/tck/tck-reactive-operators/src/test/java/io/helidon/microprofile/reactive/HelidonReactiveStreamsTckTest.java
@@ -20,9 +20,9 @@
 import org.eclipse.microprofile.reactive.streams.operators.tck.ReactiveStreamsTck;
 import org.reactivestreams.tck.TestEnvironment;
 
-public class HelidonStreamEngineTckTest extends ReactiveStreamsTck {
+public class HelidonReactiveStreamsTckTest extends ReactiveStreamsTck {
 
-    public HelidonStreamEngineTckTest() {
+    public HelidonReactiveStreamsTckTest() {
         super(new TestEnvironment(200,200,false));
     }
 

From f309ed86199043275c486811bd5e00d12ae67eb4 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 20 Dec 2019 16:40:39 +0100
Subject: [PATCH 54/66] Move additional processors to common module

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BufferedProcessor.java    | 44 +-----------
 .../common}/reactive/ConcatPublisher.java     | 46 ++++++------
 .../common}/reactive/FailedPublisher.java     |  8 +--
 .../io/helidon/common/reactive/Multi.java     | 61 +++++++++++++++-
 .../reactive/MultiCoupledProcessor.java       | 71 ++++++++-----------
 .../reactive/MultiFlatMapProcessor.java       | 65 +++++++----------
 ...gProcessor.java => MultiMapProcessor.java} | 15 +++-
 .../helidon/common}/reactive/OfPublisher.java | 17 ++---
 .../reactive/OnErrorResumeProcessor.java      | 41 ++++-------
 .../common/reactive/SubscriberReference.java  | 56 +++++++++++++++
 .../io/helidon/common/reactive/MultiTest.java | 67 +++++++++++++++--
 .../reactive/CancelSubscriber.java            | 13 ++--
 .../reactive/CollectSubscriber.java           |  3 -
 .../reactive/FindFirstSubscriber.java         | 18 ++---
 .../microprofile/reactive/GraphBuilder.java   | 38 ++++++----
 .../microprofile/reactive/MapProcessor.java   | 58 ---------------
 .../RedeemingCompletionSubscriber.java        |  2 -
 17 files changed, 329 insertions(+), 294 deletions(-)
 rename {microprofile/reactive-streams/src/main/java/io/helidon/microprofile => common/reactive/src/main/java/io/helidon/common}/reactive/ConcatPublisher.java (70%)
 rename {microprofile/reactive-streams/src/main/java/io/helidon/microprofile => common/reactive/src/main/java/io/helidon/common}/reactive/FailedPublisher.java (84%)
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java => common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java (69%)
 rename microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java => common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java (73%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{MultiMappingProcessor.java => MultiMapProcessor.java} (72%)
 rename {microprofile/reactive-streams/src/main/java/io/helidon/microprofile => common/reactive/src/main/java/io/helidon/common}/reactive/OfPublisher.java (86%)
 rename {microprofile/reactive-streams/src/main/java/io/helidon/microprofile => common/reactive/src/main/java/io/helidon/common}/reactive/OnErrorResumeProcessor.java (67%)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
 delete mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index c4fb2cfd3d8..b71ec7e74b0 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -27,7 +27,7 @@ public class BufferedProcessor extends BaseProcessor {
 
     private static final int BACK_PRESSURE_BUFFER_SIZE = 1024;
 
-    private ReferencedSubscriber referencedSubscriber;
+    private SubscriberReference referencedSubscriber;
     private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
     private ReentrantLock publisherSequentialLock = new ReentrantLock();
 
@@ -39,10 +39,9 @@ public void request(long n) {
         super.request(n);
     }
 
-
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
-        if (true && !getSubscriber().isClosed() && !buffer.isEmpty()) {
+        if (!getSubscriber().isClosed() && !buffer.isEmpty()) {
             try {
                 submit(buffer.take());
             } catch (InterruptedException e) {
@@ -57,7 +56,7 @@ protected void tryRequest(Flow.Subscription subscription) {
     public void subscribe(Flow.Subscriber s) {
         // https://github.com/reactive-streams/reactive-streams-jvm#3.13
         //TODO: Move to BaseProcessor
-        referencedSubscriber = ReferencedSubscriber.create(s);
+        referencedSubscriber = SubscriberReference.create(s);
         super.subscribe(referencedSubscriber);
     }
 
@@ -134,41 +133,4 @@ protected void superOnError(Throwable ex) {
         }
         tryComplete();
     }
-
-    private static class ReferencedSubscriber implements Flow.Subscriber {
-
-        private Optional> subscriber;
-
-        private ReferencedSubscriber(Flow.Subscriber subscriber) {
-            this.subscriber = Optional.of(subscriber);
-        }
-
-        public static  ReferencedSubscriber create(Flow.Subscriber subscriber) {
-            return new ReferencedSubscriber<>(subscriber);
-        }
-
-        public void releaseReference() {
-            this.subscriber = Optional.empty();
-        }
-
-        @Override
-        public void onSubscribe(Flow.Subscription subscription) {
-            subscriber.ifPresent(s -> s.onSubscribe(subscription));
-        }
-
-        @Override
-        public void onNext(T item) {
-            subscriber.ifPresent(s -> s.onNext(item));
-        }
-
-        @Override
-        public void onError(Throwable throwable) {
-            subscriber.ifPresent(s -> s.onError(throwable));
-        }
-
-        @Override
-        public void onComplete() {
-            subscriber.ifPresent(Flow.Subscriber::onComplete);
-        }
-    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
similarity index 70%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
index c2e8b4a5f0e..909796feb36 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ConcatPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
@@ -15,46 +15,40 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
-public class ConcatPublisher implements Publisher {
+public class ConcatPublisher implements Flow.Publisher, Multi {
     private FirstProcessor firstProcessor;
     private SecondProcessor secondProcessor;
-    private Subscriber subscriber;
-    private Publisher firstPublisher;
-    private Publisher secondPublisher;
+    private Flow.Subscriber subscriber;
+    private Flow.Publisher firstPublisher;
+    private Flow.Publisher secondPublisher;
     private AtomicLong requested = new AtomicLong();
 
 
-    public ConcatPublisher(Publisher firstPublisher, Publisher secondPublisher) {
+    public ConcatPublisher(Flow.Publisher firstPublisher, Flow.Publisher secondPublisher) {
         this.firstPublisher = firstPublisher;
         this.secondPublisher = secondPublisher;
     }
 
     @Override
-    public void subscribe(Subscriber subscriber) {
-        this.subscriber = (Subscriber) subscriber;
+    @SuppressWarnings("unchecked")
+    public void subscribe(Flow.Subscriber subscriber) {
+        this.subscriber = (Flow.Subscriber) subscriber;
 
         this.firstProcessor = new FirstProcessor();
         this.secondProcessor = new SecondProcessor();
 
         firstPublisher.subscribe(firstProcessor);
 
-        subscriber.onSubscribe(new Subscription() {
+        subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
-                if (n <= 0) {
-                    // https://github.com/reactive-streams/reactive-streams-jvm#3.9
-                    subscriber.onError(new IllegalArgumentException("non-positive subscription request"));
+                if (!StreamValidationUtils.checkRequestParam309(n, subscriber::onError)) {
                     return;
                 }
                 requested.set(n);
@@ -73,17 +67,17 @@ public void cancel() {
         });
     }
 
-    private class FirstProcessor implements Processor {
+    private class FirstProcessor implements Flow.Processor {
 
-        private Subscription subscription;
+        private Flow.Subscription subscription;
         private boolean complete = false;
 
         @Override
-        public void subscribe(Subscriber s) {
+        public void subscribe(Flow.Subscriber s) {
         }
 
         @Override
-        public void onSubscribe(Subscription subscription) {
+        public void onSubscribe(Flow.Subscription subscription) {
             Objects.requireNonNull(subscription);
             this.subscription = subscription;
             secondPublisher.subscribe(secondProcessor);
@@ -99,7 +93,7 @@ public void onNext(Object o) {
         @Override
         public void onError(Throwable t) {
             complete = true;
-            Optional.ofNullable(secondProcessor.subscription).ifPresent(Subscription::cancel);
+            Optional.ofNullable(secondProcessor.subscription).ifPresent(Flow.Subscription::cancel);
             subscription.cancel();
             ConcatPublisher.this.subscriber.onError(t);
         }
@@ -112,16 +106,16 @@ public void onComplete() {
     }
 
 
-    private class SecondProcessor implements Processor {
+    private class SecondProcessor implements Flow.Processor {
 
-        private Subscription subscription;
+        private Flow.Subscription subscription;
 
         @Override
-        public void subscribe(Subscriber s) {
+        public void subscribe(Flow.Subscriber s) {
         }
 
         @Override
-        public void onSubscribe(Subscription subscription) {
+        public void onSubscribe(Flow.Subscription subscription) {
             Objects.requireNonNull(subscription);
             this.subscription = subscription;
         }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
similarity index 84%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
index d615b1a2e91..af3f36c2de8 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FailedPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
@@ -15,11 +15,9 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
-import io.helidon.common.reactive.Flow;
-
-public class FailedPublisher implements Flow.Publisher {
+public class FailedPublisher implements Flow.Publisher, Multi {
 
     private Throwable throwable;
 
@@ -28,7 +26,7 @@ public FailedPublisher(Throwable throwable) {
     }
 
     @Override
-    public void subscribe(Flow.Subscriber subscriber) {
+    public void subscribe(Flow.Subscriber subscriber) {
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 6268a5d13be..88a4c828901 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -23,6 +23,7 @@
 import io.helidon.common.mapper.Mapper;
 
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
 /**
@@ -41,7 +42,7 @@ public interface Multi extends Subscribable {
      * @throws NullPointerException if mapper is {@code null}
      */
     default  Multi map(Mapper mapper) {
-        MultiMappingProcessor processor = new MultiMappingProcessor<>(mapper);
+        MultiMapProcessor processor = new MultiMapProcessor<>(mapper);
         this.subscribe(processor);
         return processor;
     }
@@ -129,6 +130,45 @@ default Multi skip(long skip) {
         return processor;
     }
 
+    /**
+     * Coupled processor sends items received to the passed in subscriber, and emits items received from the passed in publisher.
+     * 
    +     *     +
+     *     |  Inlet/upstream publisher
+     * +-------+
+     * |   |   |   passed in subscriber
+     * |   +-------------------------->
+     * |       |   passed in publisher
+     * |   +--------------------------+
+     * |   |   |
+     * +-------+
+     *     |  Outlet/downstream subscriber
+     *     v
+     * 
    
+     *
+     * @param                 Inlet and passed in subscriber item type
+     * @param                 Outlet and passed in publisher item type
+     * @param passedInSubscriber gets all items from upstream/inlet
+     * @param passedInPublisher  emits to downstream/outlet
+     */
+    default  Multi coupled(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
+        MultiCoupledProcessor processor = new MultiCoupledProcessor<>(passedInSubscriber, passedInPublisher);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    default Multi onErrorResume(Function onError) {
+        OnErrorResumeProcessor processor = OnErrorResumeProcessor.resume(onError);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    default Multi onErrorResumeWith(Function> onError) {
+        OnErrorResumeProcessor processor = OnErrorResumeProcessor.resumeWith(onError);
+        this.subscribe(processor);
+        return processor;
+    }
+
     /**
      * Terminal stage, invokes provided consumer for every item in the stream.
      *
@@ -189,6 +229,19 @@ static  Multi from(Publisher source) {
         return new MultiFromPublisher<>(source);
     }
 
+    /**
+     * Create a {@link Multi} instance that publishes the given iterable.
+     *
+     * @param       item type
+     * @param iterable iterable to publish
+     * @return Multi
+     * @throws NullPointerException if iterable is {@code null}
+     */
+    static  Multi from(Iterable iterable) {
+        return Multi.from(new OfPublisher(iterable));
+    }
+
+
     /**
      * Create a {@link Multi} instance that publishes the given items to a single subscriber.
      *
@@ -224,7 +277,7 @@ static  Multi just(T... items) {
      * @throws NullPointerException if error is {@code null}
      */
     static  Multi error(Throwable error) {
-        return new MultiError<>(error);
+        return new FailedPublisher(error);
     }
 
     /**
@@ -246,4 +299,8 @@ static  Multi empty() {
     static  Multi never() {
         return MultiNever.instance();
     }
+
+    static  Multi concat(Multi firstMulti, Multi secondMulti) {
+        return new ConcatPublisher<>(firstMulti, secondMulti);
+    }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
similarity index 69%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
index 52ebc82f20a..50407449ce6 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CoupledProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
@@ -15,22 +15,14 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import io.helidon.common.reactive.StreamValidationUtils;
-import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
-
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
 /**
- * Coupled processor sends all upstream.
+ * Coupled processor sends items received to the passed in subscriber, and emits items received from the passed in publisher.
  * 
      *     +
  *     |  Inlet/upstream publisher
@@ -45,51 +37,50 @@
  *     v
  * 
    
  *
- * @param 
- * @param 
- * @see org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams#coupled(org.reactivestreams.Subscriber, org.reactivestreams.Publisher)
+ * @param  Inlet and passed in subscriber item type
+ * @param  Outlet and passed in publisher item type
  */
-public class CoupledProcessor implements Processor {
+public class MultiCoupledProcessor implements Flow.Processor, Multi {
 
-    private HybridSubscriber passedInSubscriber;
-    private Publisher passedInPublisher;
-    private HybridSubscriber outletSubscriber;
-    private Subscriber inletSubscriber;
-    private Subscription inletSubscription;
-    private Subscription passedInPublisherSubscription;
+    private SubscriberReference passedInSubscriber;
+    private SubscriberReference outletSubscriber;
+    private Flow.Publisher passedInPublisher;
+    private Flow.Subscriber inletSubscriber;
+    private Flow.Subscription inletSubscription;
+    private Flow.Subscription passedInPublisherSubscription;
 
     private AtomicBoolean cancelled = new AtomicBoolean(false);
 
 
-    public CoupledProcessor(Subscriber passedInSubscriber, Publisher passedInPublisher) {
-        this.passedInSubscriber = HybridSubscriber.from(passedInSubscriber);
+    public MultiCoupledProcessor(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
+        this.passedInSubscriber = SubscriberReference.create(passedInSubscriber);
         this.passedInPublisher = passedInPublisher;
         this.inletSubscriber = this;
     }
 
     @Override
-    public void subscribe(Subscriber outletSubscriber) {
-        this.outletSubscriber = HybridSubscriber.from(outletSubscriber);
-        passedInPublisher.subscribe(new Subscriber() {
+    public void subscribe(Flow.Subscriber outletSubscriber) {
+        this.outletSubscriber = SubscriberReference.create(outletSubscriber);
+        passedInPublisher.subscribe(new Flow.Subscriber() {
 
             @Override
-            public void onSubscribe(Subscription passedInPublisherSubscription) {
+            public void onSubscribe(Flow.Subscription passedInPublisherSubscription) {
                 //Passed in publisher called onSubscribed
                 Objects.requireNonNull(passedInPublisherSubscription);
                 // https://github.com/reactive-streams/reactive-streams-jvm#2.5
-                if (Objects.nonNull(CoupledProcessor.this.passedInPublisherSubscription) || cancelled.get()) {
+                if (Objects.nonNull(MultiCoupledProcessor.this.passedInPublisherSubscription) || cancelled.get()) {
                     passedInPublisherSubscription.cancel();
                     return;
                 }
-                CoupledProcessor.this.passedInPublisherSubscription = passedInPublisherSubscription;
+                MultiCoupledProcessor.this.passedInPublisherSubscription = passedInPublisherSubscription;
             }
 
             @Override
             @SuppressWarnings("unchecked")
-            public void onNext(T t) {
+            public void onNext(R t) {
                 //Passed in publisher sent onNext
                 Objects.requireNonNull(t);
-                outletSubscriber.onNext((R) t);
+                outletSubscriber.onNext(t);
             }
 
             @Override
@@ -101,7 +92,7 @@ public void onError(Throwable t) {
                 passedInSubscriber.onError(t);
                 inletSubscriber.onError(t);
                 //203 https://github.com/eclipse/microprofile-reactive-streams-operators/issues/131
-                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
+                Optional.ofNullable(inletSubscription).ifPresent(Flow.Subscription::cancel);
             }
 
             @Override
@@ -111,11 +102,11 @@ public void onComplete() {
                 outletSubscriber.onComplete();
                 passedInSubscriber.onComplete();
                 //203 https://github.com/eclipse/microprofile-reactive-streams-operators/issues/131
-                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
+                Optional.ofNullable(inletSubscription).ifPresent(Flow.Subscription::cancel);
             }
         });
 
-        outletSubscriber.onSubscribe(new Subscription() {
+        outletSubscriber.onSubscribe(new Flow.Subscription() {
 
             @Override
             public void request(long n) {
@@ -128,16 +119,16 @@ public void request(long n) {
             public void cancel() {
                 // Cancel from outlet subscriber
                 passedInSubscriber.onComplete();
-                Optional.ofNullable(inletSubscription).ifPresent(Subscription::cancel);
+                Optional.ofNullable(inletSubscription).ifPresent(Flow.Subscription::cancel);
                 passedInPublisherSubscription.cancel();
-                CoupledProcessor.this.passedInSubscriber.releaseReferences();
-                CoupledProcessor.this.outletSubscriber.releaseReferences();
+                MultiCoupledProcessor.this.passedInSubscriber.releaseReference();
+                MultiCoupledProcessor.this.outletSubscriber.releaseReference();
             }
         });
     }
 
     @Override
-    public void onSubscribe(Subscription inletSubscription) {
+    public void onSubscribe(Flow.Subscription inletSubscription) {
         Objects.requireNonNull(inletSubscription);
         // https://github.com/reactive-streams/reactive-streams-jvm#2.5
         if (Objects.nonNull(this.inletSubscription) || cancelled.get()) {
@@ -145,7 +136,7 @@ public void onSubscribe(Subscription inletSubscription) {
             return;
         }
         this.inletSubscription = inletSubscription;
-        passedInSubscriber.onSubscribe(new Subscription() {
+        passedInSubscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
                 StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> passedInSubscriber.onError(t));
@@ -161,8 +152,8 @@ public void cancel() {
                 inletSubscription.cancel();
                 outletSubscriber.onComplete();
                 passedInPublisherSubscription.cancel();
-                passedInSubscriber.releaseReferences();
-                outletSubscriber.releaseReferences();
+                passedInSubscriber.releaseReference();
+                outletSubscriber.releaseReference();
             }
         });
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
similarity index 73%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index 4924552b758..f3e14a0be4b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -15,7 +15,7 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
 import java.util.Objects;
 import java.util.Optional;
@@ -24,56 +24,46 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.RequestedCounter;
-import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
-
-import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
-import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
 /**
  * Flatten the elements emitted by publishers produced by the mapper function to this stream.
  */
-public class FlatMapProcessor implements Processor {
+public class MultiFlatMapProcessor implements Flow.Processor, Multi {
 
-    private Function mapper;
-    private HybridSubscriber subscriber;
-    private Subscription subscription;
+    private Function> mapper;
+    private SubscriberReference subscriber;
+    private Flow.Subscription subscription;
     private RequestedCounter requestCounter = new RequestedCounter();
-    private Subscription innerSubscription;
+    private Flow.Subscription innerSubscription;
     private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
 
     private PublisherBuffer buffer;
 
     private Optional error = Optional.empty();
 
-    private FlatMapProcessor() {
+    private MultiFlatMapProcessor() {
         buffer = new PublisherBuffer();
     }
 
     @SuppressWarnings("unchecked")
-    static FlatMapProcessor fromIterableMapper(Function> mapper) {
+    public static MultiFlatMapProcessor fromIterableMapper(Function> mapper) {
         Function> iterableMapper = (Function>) mapper;
-        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
-        flatMapProcessor.mapper = o -> ReactiveStreams.fromIterable(iterableMapper.apply(o)).buildRs();
+        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
+        flatMapProcessor.mapper = o -> (Multi) Multi.from(iterableMapper.apply(o));
         return flatMapProcessor;
     }
 
     @SuppressWarnings("unchecked")
-    static FlatMapProcessor fromPublisherMapper(Function mapper) {
-        Function publisherMapper = (Function) mapper;
-        FlatMapProcessor flatMapProcessor = new FlatMapProcessor();
-        flatMapProcessor.mapper = o -> new HelidonReactiveStreamEngine().buildPublisher(publisherMapper.apply(o));
+    public static MultiFlatMapProcessor fromPublisherMapper(Function> mapper) {
+        Function> publisherMapper = (Function>) mapper;
+        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
+        flatMapProcessor.mapper = publisherMapper;
         return flatMapProcessor;
     }
 
-    private class FlatMapSubscription implements Subscription {
+    private class FlatMapSubscription implements Flow.Subscription {
         @Override
         public void request(long n) {
-            requestCounter.increment(n, FlatMapProcessor.this::onError);
+            requestCounter.increment(n, MultiFlatMapProcessor.this::onError);
 
             if (buffer.isComplete() || Objects.isNull(innerSubscription)) {
                 subscription.request(requestCounter.get());
@@ -85,15 +75,15 @@ public void request(long n) {
         @Override
         public void cancel() {
             subscription.cancel();
-            Optional.ofNullable(innerSubscription).ifPresent(Subscription::cancel);
+            Optional.ofNullable(innerSubscription).ifPresent(Flow.Subscription::cancel);
             // https://github.com/reactive-streams/reactive-streams-jvm#3.13
-            subscriber.releaseReferences();
+            subscriber.releaseReference();
         }
     }
 
     @Override
-    public void subscribe(Subscriber subscriber) {
-        this.subscriber = HybridSubscriber.from(subscriber);
+    public void subscribe(Flow.Subscriber subscriber) {
+        this.subscriber = SubscriberReference.create(subscriber);
         if (Objects.nonNull(this.subscription)) {
             subscriber.onSubscribe(new FlatMapSubscription());
         }
@@ -101,7 +91,7 @@ public void subscribe(Subscriber subscriber) {
     }
 
     @Override
-    public void onSubscribe(Subscription subscription) {
+    public void onSubscribe(Flow.Subscription subscription) {
         if (Objects.nonNull(this.subscription)) {
             subscription.cancel();
             return;
@@ -113,7 +103,6 @@ public void onSubscribe(Subscription subscription) {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
     public void onNext(Object o) {
         Objects.requireNonNull(o);
         buffer.offer(o);
@@ -176,7 +165,7 @@ public InnerSubscriber executeMapper(Object item) {
         }
     }
 
-    private class InnerSubscriber implements Subscriber {
+    private class InnerSubscriber implements Flow.Subscriber {
 
         private AtomicBoolean subscriptionAcked = new AtomicBoolean(false);
         private AtomicBoolean done = new AtomicBoolean(false);
@@ -184,14 +173,14 @@ private class InnerSubscriber implements Subscriber {
         private Optional whenCompleteObserver = Optional.empty();
 
         @Override
-        public void onSubscribe(Subscription innerSubscription) {
+        public void onSubscribe(Flow.Subscription innerSubscription) {
             Objects.requireNonNull(innerSubscription);
             if (subscriptionAcked.get()) {
                 innerSubscription.cancel();
                 return;
             }
             subscriptionAcked.set(true);
-            FlatMapProcessor.this.innerSubscription = innerSubscription;
+            MultiFlatMapProcessor.this.innerSubscription = innerSubscription;
             long requestCount = requestCounter.get();
             if (requestCount > 0) {
                 innerSubscription.request(requestCount);
@@ -201,7 +190,7 @@ public void onSubscribe(Subscription innerSubscription) {
         @Override
         public void onNext(Object o) {
             Objects.requireNonNull(o);
-            FlatMapProcessor.this.subscriber.onNext(o);
+            MultiFlatMapProcessor.this.subscriber.onNext(o);
             requestCounter.tryDecrement();
             long requestCount = requestCounter.get();
             if (requestCount > 0) {
@@ -212,8 +201,8 @@ public void onNext(Object o) {
         @Override
         public void onError(Throwable t) {
             Objects.requireNonNull(t);
-            FlatMapProcessor.this.subscription.cancel();
-            FlatMapProcessor.this.onError(t);
+            MultiFlatMapProcessor.this.subscription.cancel();
+            MultiFlatMapProcessor.this.onError(t);
         }
 
         @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
similarity index 72%
rename from common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
index 0d0aa750bb3..75d31aa294a 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMappingProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
@@ -26,23 +26,32 @@
  * @param  subscribed type
  * @param  published type
  */
-public final class MultiMappingProcessor extends BufferedProcessor implements Multi {
+public final class MultiMapProcessor extends BufferedProcessor implements Multi {
 
     private final Mapper mapper;
 
     /**
      * Processor of {@link Publisher} to {@link Single} that publishes and maps each received item.
+     *
      * @param mapper supplied for all items to be mapped with
      */
-    public MultiMappingProcessor(Mapper mapper) {
+    public MultiMapProcessor(Mapper mapper) {
         this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
     }
 
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        subscription.cancel();
+    }
+
     @Override
     protected void hookOnNext(T item) {
         U value = mapper.map(item);
         if (value == null) {
-            onError(new IllegalStateException("Mapper returned a null value"));
+            getSubscription().ifPresent(Flow.Subscription::cancel);
+            //TODO: ask Romain if IllegalStateException is really needed, RS operators TCKs expect NullPointerException
+            onError(new NullPointerException("Mapper returned a null value"));
         } else {
             submit(value);
         }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
similarity index 86%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
index 85cfaefe93c..eaebc5f6259 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OfPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
@@ -15,31 +15,28 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.RequestedCounter;
-
-public class OfPublisher implements Flow.Publisher {
-    private Iterable iterable;
+public class OfPublisher implements Flow.Publisher {
+    private Iterable iterable;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
     private AtomicBoolean completed = new AtomicBoolean(false);
     private AtomicBoolean trampolineLock = new AtomicBoolean(false);
     private final RequestedCounter requestCounter = new RequestedCounter();
     private final ReentrantLock iterateConcurrentLock = new ReentrantLock();
 
-    public OfPublisher(Iterable iterable) {
+    public OfPublisher(Iterable iterable) {
         this.iterable = iterable;
     }
 
     @Override
-    public void subscribe(Flow.Subscriber subscriber) {
-        final Iterator iterator;
+    public void subscribe(Flow.Subscriber subscriber) {
+        final Iterator iterator;
         try {
             iterator = iterable.iterator();
         } catch (Throwable t) {
@@ -59,7 +56,7 @@ private void trySubmit() {
                         while (requestCounter.tryDecrement()) {
                             iterateConcurrentLock.lock();
                             if (iterator.hasNext() && !cancelled.get()) {
-                                Object next = iterator.next();
+                                T next = iterator.next();
                                 iterateConcurrentLock.unlock();
                                 Objects.requireNonNull(next);
                                 subscriber.onNext(next);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
similarity index 67%
rename from microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
index ccfefd47979..3234a63d732 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/OnErrorResumeProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
@@ -15,55 +15,39 @@
  *
  */
 
-package io.helidon.microprofile.reactive;
+package io.helidon.common.reactive;
 
 import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.BufferedProcessor;
-import io.helidon.microprofile.reactive.hybrid.HybridSubscription;
+public class OnErrorResumeProcessor extends BufferedProcessor implements Multi {
 
-import org.eclipse.microprofile.reactive.streams.operators.spi.Graph;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-
-public class OnErrorResumeProcessor extends BufferedProcessor {
-
-
-    private AtomicBoolean completed = new AtomicBoolean(false);
     private Function supplier;
-    private Function> publisherSupplier;
+    private Function> publisherSupplier;
     //TODO: sync access - onError can do async write?
-    private Optional onErrorPublisherSubscription = Optional.empty();
+    private Optional onErrorPublisherSubscription = Optional.empty();
 
     private OnErrorResumeProcessor() {
     }
 
     @SuppressWarnings("unchecked")
-    static  OnErrorResumeProcessor resume(Function supplier) {
+    public static  OnErrorResumeProcessor resume(Function supplier) {
         OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
         processor.supplier = (Function) supplier;
         return processor;
     }
 
-    static  OnErrorResumeProcessor resumeWith(Function supplier) {
+    public static  OnErrorResumeProcessor resumeWith(Function> supplier) {
         OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
-        processor.publisherSupplier = throwable -> GraphBuilder.create().from(supplier.apply(throwable)).getPublisher();
+        processor.publisherSupplier = supplier;
         return processor;
     }
 
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
-        if (completed.get()) {
-            tryComplete();
-        }
-
         if (onErrorPublisherSubscription.isPresent()) {
-            super.tryRequest(HybridSubscription.from(onErrorPublisherSubscription.get()));
+            super.tryRequest(onErrorPublisherSubscription.get());
         } else {
             super.tryRequest(subscription);
         }
@@ -80,15 +64,14 @@ public void onError(Throwable ex) {
         try {
             if (Objects.nonNull(supplier)) {
 
-                completed.set(true);
                 submit(supplier.apply(ex));
                 tryComplete();
 
             } else {
-                publisherSupplier.apply(ex).subscribe(new Subscriber() {
+                publisherSupplier.apply(ex).subscribe(new Flow.Subscriber() {
 
                     @Override
-                    public void onSubscribe(Subscription subscription) {
+                    public void onSubscribe(Flow.Subscription subscription) {
                         Objects.requireNonNull(subscription);
                         onErrorPublisherSubscription = Optional.of(subscription);
                         if (getRequestedCounter().get() > 0) {
@@ -115,7 +98,7 @@ public void onComplete() {
                 });
             }
         } catch (Throwable t) {
-            onErrorPublisherSubscription.ifPresent(Subscription::cancel);
+            onErrorPublisherSubscription.ifPresent(Flow.Subscription::cancel);
             superOnError(t);
         }
     }
@@ -123,6 +106,6 @@ public void onComplete() {
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         subscription.cancel();
-        onErrorPublisherSubscription.ifPresent(Subscription::cancel);
+        onErrorPublisherSubscription.ifPresent(Flow.Subscription::cancel);
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
new file mode 100644
index 00000000000..940e3c8c18a
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.Optional;
+
+public class SubscriberReference implements Flow.Subscriber {
+    private Optional> subscriber;
+
+    private SubscriberReference(Flow.Subscriber subscriber) {
+        this.subscriber = Optional.of(subscriber);
+    }
+
+    public static  SubscriberReference create(Flow.Subscriber subscriber) {
+        return new SubscriberReference<>(subscriber);
+    }
+
+    public void releaseReference() {
+        this.subscriber = Optional.empty();
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        subscriber.ifPresent(s -> s.onSubscribe(subscription));
+    }
+
+    @Override
+    public void onNext(T item) {
+        subscriber.ifPresent(s -> s.onNext(item));
+    }
+
+    @Override
+    public void onError(Throwable throwable) {
+        subscriber.ifPresent(s -> s.onError(throwable));
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.ifPresent(Flow.Subscriber::onComplete);
+    }
+}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index 9ad139f9156..75387275cef 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -20,8 +20,13 @@
 import java.util.Collections;
 import java.util.concurrent.Flow.Subscription;
 
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import io.helidon.common.mapper.Mapper;
 
@@ -238,14 +243,10 @@ public String map(String item) {
     @Test
     public void testMapBadMapperNullValue() {
         MultiTestSubscriber subscriber = new MultiTestSubscriber<>();
-        Multi.just("foo", "bar").map(new Mapper() {
-            @Override
-            public String map(String item) {
-                return null;
-            }
-        }).subscribe(subscriber);
+        Multi.just("foo", "bar").map((Mapper) item -> null).subscribe(subscriber);
         assertThat(subscriber.isComplete(), is(equalTo(false)));
-        assertThat(subscriber.getLastError(), is(instanceOf(IllegalStateException.class)));
+        //TODO: ask Romain if IllegalStateException is really needed, RS operators TCKs expect NullPointerException
+        assertThat(subscriber.getLastError(), is(instanceOf(NullPointerException.class)));
         assertThat(subscriber.getItems(), is(empty()));
     }
 
@@ -350,6 +351,58 @@ void testDropWhile() throws ExecutionException, InterruptedException {
         assertThat(result, is(equalTo(EXPECTED)));
     }
 
+
+    @Test
+    void testOnErrorResumeWith() throws ExecutionException, InterruptedException, TimeoutException {
+        List result = Multi.error(new RuntimeException())
+                .onErrorResumeWith(throwable -> Multi.just(1, 2, 3))
+                .collectList()
+                .get(100, TimeUnit.MILLISECONDS);
+
+        assertThat(result, is(equalTo(List.of(1, 2, 3))));
+    }
+
+    @Test
+    void testCoupled() throws ExecutionException, InterruptedException, TimeoutException {
+        final List TEST_DATA = List.of(1, 2, 3, 4, 3, 2, 1, 0);
+
+        CountDownLatch countDownLatch = new CountDownLatch(TEST_DATA.size());
+        PeekProcessor peekProcessor = new PeekProcessor<>(i -> countDownLatch.countDown());
+
+        List result = Multi.just(TEST_DATA)
+                .coupled(peekProcessor, peekProcessor)
+                .collectList()
+                .get(1, TimeUnit.SECONDS);
+
+        countDownLatch.await(1, TimeUnit.SECONDS);
+        assertThat(result, is(equalTo(TEST_DATA)));
+    }
+
+    @Test
+    void testOnErrorResume() throws ExecutionException, InterruptedException, TimeoutException {
+        Integer result = Multi.error(new RuntimeException())
+                .onErrorResume(throwable -> 1)
+                .first()
+                .get(100, TimeUnit.MILLISECONDS);
+
+        assertThat(result, is(equalTo(1)));
+    }
+
+    @Test
+    void testConcat() throws ExecutionException, InterruptedException {
+        final List TEST_DATA_1 = Arrays.asList(1, 2, 3, 4, 3, 2, 1, 0);
+        final List TEST_DATA_2 = Arrays.asList(11, 12, 13, 14, 13, 12, 11, 10);
+        final List EXPECTED = Stream.concat(TEST_DATA_1.stream(), TEST_DATA_2.stream())
+                .collect(Collectors.toList());
+
+        List result = Multi
+                .concat(Multi.from(TEST_DATA_1), Multi.just(TEST_DATA_2))
+                .collectList()
+                .get();
+
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
+
     @Test
     void distinct() throws ExecutionException, InterruptedException {
         final List TEST_DATA = Arrays.asList(1, 2, 1, 2, 3, 2, 1, 3);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index f7904eec478..89189ea703c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -29,9 +29,9 @@
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.reactivestreams.Subscriber;
 
-public class CancelSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage {
+public class CancelSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage> {
 
-    private CompletableFuture completionStage = new CompletableFuture<>();
+    private CompletableFuture> completionStage = new CompletableFuture<>();
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
@@ -40,7 +40,7 @@ public void onSubscribe(Flow.Subscription subscription) {
     }
 
     @Override
-    public void onNext(Object item) {
+    public void onNext(T item) {
         Objects.requireNonNull(item);
         throw new CancellationException();
     }
@@ -53,18 +53,17 @@ public void onError(Throwable throwable) {
     @Override
     public void onComplete() {
         if (!completionStage.isDone()) {
-            Object optItem = (Object) Optional.empty();
-            completionStage.complete(optItem);
+            completionStage.complete(Optional.empty());
         }
     }
 
     @Override
-    public CompletionStage getCompletion() {
+    public CompletionStage> getCompletion() {
         return completionStage;
     }
 
     @Override
-    public Subscriber getSubscriber() {
+    public Subscriber getSubscriber() {
         return HybridSubscriber.from(this);
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index 4842f2f5c34..eeace753437 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -141,9 +141,6 @@ public void onComplete() {
                 } catch (Throwable t) {
                     onError(t);
                 }
-                if (Objects.nonNull(subscription)) {
-                    //subscription.cancel();
-                }
             }
         };
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index 7d58c8660ba..862016dd752 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -28,9 +28,9 @@
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
 import org.reactivestreams.Subscriber;
 
-public class FindFirstSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage {
+public class FindFirstSubscriber implements Flow.Subscriber, SubscriberWithCompletionStage> {
     private Flow.Subscription subscription;
-    private CompletableFuture completionStage = new CompletableFuture<>();
+    private CompletableFuture> completionStage = new CompletableFuture<>();
 
     @Override
     public void onSubscribe(Flow.Subscription subscription) {
@@ -46,11 +46,9 @@ public void onSubscribe(Flow.Subscription subscription) {
 
 
     @Override
-    @SuppressWarnings("unchecked")
-    public void onNext(Object item) {
+    public void onNext(T item) {
         subscription.cancel();
-        Object optItem = (Object) Optional.of(item);
-        completionStage.complete(optItem);
+        completionStage.complete(Optional.of(item));
     }
 
     @Override
@@ -59,21 +57,19 @@ public void onError(Throwable throwable) {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
     public void onComplete() {
         if (!completionStage.isDone()) {
-            Object optItem = (Object) Optional.empty();
-            completionStage.complete(optItem);
+            completionStage.complete(Optional.empty());
         }
     }
 
     @Override
-    public CompletionStage getCompletion() {
+    public CompletionStage> getCompletion() {
         return completionStage;
     }
 
     @Override
-    public Subscriber getSubscriber() {
+    public Subscriber getSubscriber() {
         return HybridSubscriber.from(this);
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index c77d22d0a4c..6637e6ab741 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -25,17 +25,25 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import io.helidon.common.reactive.BufferedProcessor;
+import io.helidon.common.reactive.ConcatPublisher;
+import io.helidon.common.reactive.MultiCoupledProcessor;
 import io.helidon.common.reactive.DistinctProcessor;
 import io.helidon.common.reactive.DropWhileProcessor;
+import io.helidon.common.reactive.FailedPublisher;
 import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.MultiFlatMapProcessor;
 import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.LimitProcessor;
 import io.helidon.common.reactive.Multi;
+import io.helidon.common.reactive.MultiMapProcessor;
+import io.helidon.common.reactive.OfPublisher;
+import io.helidon.common.reactive.OnErrorResumeProcessor;
 import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.common.reactive.BufferedProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
+import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.eclipse.microprofile.reactive.streams.operators.CompletionSubscriber;
@@ -61,15 +69,15 @@ private GraphBuilder() {
         });
         registerStage(Stage.Concat.class, stage -> {
             HelidonReactiveStreamEngine streamEngine = new HelidonReactiveStreamEngine();
-            Publisher firstPublisher = streamEngine.buildPublisher(stage.getFirst());
-            Publisher secondPublisher = streamEngine.buildPublisher(stage.getSecond());
-            multi = MultiRS.toMulti(new ConcatPublisher<>(firstPublisher, secondPublisher));
+            HybridPublisher firstPublisher = HybridPublisher.from(streamEngine.buildPublisher(stage.getFirst()));
+            HybridPublisher secondPublisher = HybridPublisher.from(streamEngine.buildPublisher(stage.getSecond()));
+            multi = new ConcatPublisher<>(firstPublisher, secondPublisher);
         });
         registerStage(Stage.Of.class, stage -> {
             multi = Multi.from(new OfPublisher(stage.getElements()));
         });
         registerStage(Stage.Failed.class, stage -> {
-            multi = Multi.from(new FailedPublisher(stage.getError()));
+            multi = Multi.from(new FailedPublisher<>(stage.getError()));
         });
         registerStage(Stage.FromCompletionStage.class, stage -> {
             multi = MultiRS.toMulti(new FromCompletionStagePublisher<>(stage.getCompletionStage(), false));
@@ -79,7 +87,7 @@ private GraphBuilder() {
         });
         registerStage(Stage.Map.class, stage -> {
             Function mapper = (Function) stage.getMapper();
-            addProcessor(new MapProcessor<>(mapper::apply));
+            addProcessor(new MultiMapProcessor<>(mapper::apply));
         });
         registerStage(Stage.Filter.class, stage -> {
             addProcessor(new FilterProcessor<>(stage.getPredicate()));
@@ -107,10 +115,14 @@ private GraphBuilder() {
             addProcessor(new DistinctProcessor<>());
         });
         registerStage(Stage.FlatMap.class, stage -> {
-            addProcessor(FlatMapProcessor.fromPublisherMapper(stage.getMapper()));
+            Function> pubMapper = o -> {
+                Function oMapper = (Function) stage.getMapper();
+                return HybridPublisher.from(new HelidonReactiveStreamEngine().buildPublisher(oMapper.apply(o)));
+            };
+            addProcessor(MultiFlatMapProcessor.fromPublisherMapper(pubMapper));
         });
         registerStage(Stage.FlatMapIterable.class, stage -> {
-            addProcessor(FlatMapProcessor.fromIterableMapper(stage.getMapper()));
+            addProcessor(MultiFlatMapProcessor.fromIterableMapper(stage.getMapper()));
         });
         registerStage(Stage.FlatMapCompletionStage.class, stage -> {
             addProcessor(new FlatMapCompletionStageProcessor(stage.getMapper()));
@@ -119,7 +131,7 @@ private GraphBuilder() {
             Subscriber subscriber = GraphBuilder.create()
                     .from(stage.getSubscriber()).getSubscriberWithCompletionStage().getSubscriber();
             Publisher publisher = GraphBuilder.create().from(stage.getPublisher()).getPublisher();
-            addProcessor(new CoupledProcessor<>(subscriber, publisher));
+            addProcessor(new MultiCoupledProcessor<>(HybridSubscriber.from(subscriber), HybridPublisher.from(publisher)));
         });
         registerStage(Stage.OnTerminate.class, stage -> {
             addProcessor(TappedProcessor.create()
@@ -137,15 +149,17 @@ private GraphBuilder() {
             addProcessor(OnErrorResumeProcessor.resume(stage.getFunction()));
         });
         registerStage(Stage.OnErrorResumeWith.class, stage -> {
-            addProcessor(OnErrorResumeProcessor.resumeWith(stage.getFunction()));
+            Function> publisherSupplier = throwable ->
+                    HybridPublisher.from(GraphBuilder.create().from(stage.getFunction().apply(throwable)).getPublisher());
+            addProcessor(OnErrorResumeProcessor.resumeWith(publisherSupplier));
         });
         registerStage(Stage.Cancel.class, stage -> {
-            CancelSubscriber cancelSubscriber = new CancelSubscriber();
+            CancelSubscriber cancelSubscriber = new CancelSubscriber<>();
             subscribe(cancelSubscriber);
             this.subscriberWithCompletionStage = cancelSubscriber;
         });
         registerStage(Stage.FindFirst.class, stage -> {
-            FindFirstSubscriber firstSubscriber = new FindFirstSubscriber<>();
+            FindFirstSubscriber firstSubscriber = new FindFirstSubscriber<>();
             subscribe(firstSubscriber);
             this.subscriberWithCompletionStage = firstSubscriber;
         });
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
deleted file mode 100644
index a0af9323ea9..00000000000
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MapProcessor.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.reactive;
-
-import java.util.Objects;
-
-import io.helidon.common.mapper.Mapper;
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.BufferedProcessor;
-
-/**
- * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
- *
- * @param  subscribed type
- * @param  published type
- */
-public final class MapProcessor extends BufferedProcessor {
-
-    private final Mapper mapper;
-
-    /**
-     * Processor of {@link io.helidon.common.reactive.Flow.Publisher} to {@link io.helidon.common.reactive.Single} that publishes and maps each received item.
-     *
-     * @param mapper supplied for all items to be mapped with
-     */
-    public MapProcessor(Mapper mapper) {
-        this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
-    }
-
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        subscription.cancel();
-    }
-
-    @Override
-    protected void hookOnNext(T item) {
-        U value = mapper.map(item);
-        if (value == null) {
-            getSubscription().get().cancel();
-            onError(new NullPointerException("Mapper returned a null value"));
-        } else {
-            submit(value);
-        }
-    }
-}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
index 6fa95dd2dbd..62556aee664 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/RedeemingCompletionSubscriber.java
@@ -96,7 +96,5 @@ public void onError(Throwable t) {
     @Override
     public void onComplete() {
         subscriber.onComplete();
-        //Base processor breaks cancel->onComplete loop, so listen even for upstream call
-        //completion.toCompletableFuture().complete(null);
     }
 }

From 2a4270aeb06d246456de0bde18656fdd65cf60a9 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 27 Dec 2019 13:56:36 +0100
Subject: [PATCH 55/66] Move tapped processor to common module   * Sequential
 lock for onSubscribe call

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BufferedProcessor.java    |   2 +
 .../io/helidon/common/reactive/Multi.java     |  48 +++++++
 .../common/reactive/TappedProcessor.java      | 117 ++++++++++++++++++
 .../io/helidon/common/reactive/MultiTest.java |  40 ++++++
 .../reactive/CumulativeProcessor.java         |   1 +
 .../microprofile/reactive/GraphBuilder.java   |   1 +
 .../reactive/TappedProcessor.java             |  84 -------------
 .../reactive/TappedSubscription.java          |  56 ---------
 .../reactive/AbstractProcessorTest.java       |   2 +-
 .../reactive/CoupledProcessorTest.java        |   2 +-
 .../reactive/TappedProcessorTest.java         |   2 +-
 11 files changed, 212 insertions(+), 143 deletions(-)
 create mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java
 delete mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
 delete mode 100644 microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index b71ec7e74b0..25ba6c7c43f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -57,7 +57,9 @@ public void subscribe(Flow.Subscriber s) {
         // https://github.com/reactive-streams/reactive-streams-jvm#3.13
         //TODO: Move to BaseProcessor
         referencedSubscriber = SubscriberReference.create(s);
+        publisherSequentialLock.lock();
         super.subscribe(referencedSubscriber);
+        publisherSequentialLock.unlock();
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 88a4c828901..8aff3046094 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -150,6 +150,7 @@ default Multi skip(long skip) {
      * @param                 Outlet and passed in publisher item type
      * @param passedInSubscriber gets all items from upstream/inlet
      * @param passedInPublisher  emits to downstream/outlet
+     * @return Multi
      */
     default  Multi coupled(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
         MultiCoupledProcessor processor = new MultiCoupledProcessor<>(passedInSubscriber, passedInPublisher);
@@ -157,6 +158,53 @@ default  Multi coupled(Flow.Subscriber passedInSubscriber, Flow.Publish
         return processor;
     }
 
+    /**
+     * Executes given {@link java.lang.Runnable} when any of signals onComplete, onCancel or onError is received.
+     *
+     * @param onTerminate {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onTerminate(Runnable onTerminate) {
+        TappedProcessor processor = TappedProcessor.create()
+                .onComplete(onTerminate)
+                .onCancel((s) -> onTerminate.run())
+                .onError((t) -> onTerminate.run());
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Executes given {@link java.lang.Runnable} when onComplete signal is received.
+     *
+     * @param onTerminate {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onComplete(Runnable onTerminate) {
+        TappedProcessor processor = TappedProcessor.create()
+                .onComplete(onTerminate);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Executes given {@link java.lang.Runnable} when onError signal is received.
+     *
+     * @param onErrorConsumer {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onError(Consumer onErrorConsumer) {
+        TappedProcessor processor = TappedProcessor.create()
+                .onError(onErrorConsumer);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * {@link java.util.function.Function} providing one item to be submitted as onNext in case of onError signal is received.
+     *
+     * @param onError Function receiving {@link java.lang.Throwable} as argument and producing one item to resume stream with.
+     * @return Multi
+     */
     default Multi onErrorResume(Function onError) {
         OnErrorResumeProcessor processor = OnErrorResumeProcessor.resume(onError);
         this.subscribe(processor);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java
new file mode 100644
index 00000000000..b4a9d03f013
--- /dev/null
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * 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 io.helidon.common.reactive;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Processor executing provided functions on passing signals onNext, onError, onComplete, onCancel.
+ *
+ * @param  Type of the processed items.
+ */
+public class TappedProcessor extends BufferedProcessor implements Multi {
+
+    private Optional> onNextFunction = Optional.empty();
+    private Optional> onErrorConsumer = Optional.empty();
+    private Optional onCompleteRunnable = Optional.empty();
+    private Optional> onCancelConsumer = Optional.empty();
+
+    private TappedProcessor() {
+    }
+
+    /**
+     * Create new processor with no functions to execute when signals are intercepted.
+     *
+     * @param  Type of the processed items.
+     * @return Brand new {@link io.helidon.common.reactive.TappedProcessor}
+     */
+    public static  TappedProcessor create() {
+        return new TappedProcessor<>();
+    }
+
+    /**
+     * Set {@link java.util.function.Function} to be executed when onNext signal is intercepted.
+     *
+     * @param function Function to be invoked.
+     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     */
+    public TappedProcessor onNext(Function function) {
+        onNextFunction = Optional.ofNullable(function);
+        return this;
+    }
+
+    /**
+     * Set {@link java.util.function.Consumer} to be executed when onError signal is intercepted.
+     *
+     * @param consumer Consumer to be executed when onError signal is intercepted,
+     *                 argument is intercepted {@link java.lang.Throwable}.
+     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     */
+    public TappedProcessor onError(Consumer consumer) {
+        onErrorConsumer = Optional.ofNullable(consumer);
+        return this;
+    }
+
+    /**
+     * Set {@link java.lang.Runnable} to be executed when onComplete signal is intercepted.
+     *
+     * @param runnable {@link java.lang.Runnable} to be executed.
+     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     */
+    public TappedProcessor onComplete(Runnable runnable) {
+        onCompleteRunnable = Optional.ofNullable(runnable);
+        return this;
+    }
+
+    /**
+     * Set consumer to be executed when onCancel signal is intercepted.
+     *
+     * @param consumer Consumer to be executed when onCancel signal is intercepted,
+     *                 argument is intercepted {@link io.helidon.common.reactive.Flow.Subscription}.
+     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     */
+    public TappedProcessor onCancel(Consumer consumer) {
+        onCancelConsumer = Optional.ofNullable(consumer);
+        return this;
+    }
+
+    @Override
+    protected void hookOnNext(R item) {
+        submit(onNextFunction.map(f -> f.apply(item)).orElse(item));
+    }
+
+    @Override
+    protected void hookOnError(Throwable error) {
+        onErrorConsumer.ifPresent(c -> c.accept(error));
+        super.hookOnError(error);
+    }
+
+    @Override
+    protected void hookOnComplete() {
+        onCompleteRunnable.ifPresent(Runnable::run);
+        super.hookOnComplete();
+    }
+
+    @Override
+    protected void hookOnCancel(Flow.Subscription subscription) {
+        onCancelConsumer.ifPresent(c -> c.accept(subscription));
+        subscription.cancel();
+    }
+}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index 75387275cef..a714dfd66cc 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -20,6 +20,7 @@
 import java.util.Collections;
 import java.util.concurrent.Flow.Subscription;
 
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -388,6 +389,45 @@ void testOnErrorResume() throws ExecutionException, InterruptedException, Timeou
         assertThat(result, is(equalTo(1)));
     }
 
+    @Test
+    void testOnError() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture beenError = new CompletableFuture<>();
+        Multi.error(new RuntimeException())
+                .onError(beenError::complete)
+                .collectList();
+
+        beenError.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void testOnComplete() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture completed = new CompletableFuture<>();
+        Multi.just(1, 2, 3)
+                .onComplete(() -> completed.complete(null))
+                .collectList()
+                .get(100, TimeUnit.MILLISECONDS);
+
+        completed.get(1, TimeUnit.SECONDS);
+    }
+
+    @Test
+    void testOnTerminate() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture completed = new CompletableFuture<>();
+        CompletableFuture beenError = new CompletableFuture<>();
+
+        Multi.just(1, 2, 3)
+                .onTerminate(() -> completed.complete(null))
+                .first()
+                .get(100, TimeUnit.MILLISECONDS);
+
+        Multi.error(new RuntimeException())
+                .onTerminate(() -> beenError.complete(null))
+                .first();
+
+        beenError.get(1, TimeUnit.SECONDS);
+        completed.get(1, TimeUnit.SECONDS);
+    }
+
     @Test
     void testConcat() throws ExecutionException, InterruptedException {
         final List TEST_DATA_1 = Arrays.asList(1, 2, 3, 4, 3, 2, 1, 0);
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index 584680f5c90..bdda47ba534 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -23,6 +23,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.helidon.common.reactive.Flow;
+import io.helidon.common.reactive.TappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.reactivestreams.Processor;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 6637e6ab741..c4ae9b27a9b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -42,6 +42,7 @@
 import io.helidon.common.reactive.PeekProcessor;
 import io.helidon.common.reactive.SkipProcessor;
 import io.helidon.common.reactive.TakeWhileProcessor;
+import io.helidon.common.reactive.TappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
deleted file mode 100644
index 01be11aac88..00000000000
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedProcessor.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.reactive;
-
-import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.BufferedProcessor;
-
-public class TappedProcessor extends BufferedProcessor {
-
-    private Optional> onNextFunction = Optional.empty();
-    private Optional> onErrorConsumer = Optional.empty();
-    private Optional onCompleteRunnable = Optional.empty();
-    private Optional> onCancelConsumer = Optional.empty();
-
-    private TappedProcessor() {
-    }
-
-    public static TappedProcessor create() {
-        TappedProcessor processor = new TappedProcessor();
-        return processor;
-    }
-
-    public TappedProcessor onNext(Function function) {
-        onNextFunction = Optional.ofNullable(function);
-        return this;
-    }
-
-    public TappedProcessor onError(Consumer consumer) {
-        onErrorConsumer = Optional.ofNullable(consumer);
-        return this;
-    }
-
-    public TappedProcessor onComplete(Runnable runnable) {
-        onCompleteRunnable = Optional.ofNullable(runnable);
-        return this;
-    }
-
-    public TappedProcessor onCancel(Consumer consumer) {
-        onCancelConsumer = Optional.ofNullable(consumer);
-        return this;
-    }
-
-    @Override
-    protected void hookOnNext(Object item) {
-        submit(onNextFunction.map(f -> f.apply(item)).orElse(item));
-    }
-
-    @Override
-    protected void hookOnError(Throwable error) {
-        onErrorConsumer.ifPresent(c -> c.accept(error));
-        super.hookOnError(error);
-    }
-
-    @Override
-    protected void hookOnComplete() {
-        onCompleteRunnable.ifPresent(Runnable::run);
-        super.hookOnComplete();
-    }
-
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        onCancelConsumer.ifPresent(c -> c.accept(subscription));
-        subscription.cancel();
-    }
-}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java
deleted file mode 100644
index f0ff8ec26a2..00000000000
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/TappedSubscription.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.microprofile.reactive;
-
-import java.util.Optional;
-import java.util.function.Consumer;
-
-import org.reactivestreams.Subscription;
-
-public class TappedSubscription implements Subscription {
-
-    private Optional> onRequest = Optional.empty();
-    private Optional onCancel = Optional.empty();
-
-    private TappedSubscription() {
-    }
-
-    public static TappedSubscription create() {
-        return new TappedSubscription();
-    }
-
-    public TappedSubscription onRequest(Consumer onRequest) {
-        this.onRequest = Optional.of(onRequest);
-        return this;
-    }
-
-    public TappedSubscription onCancel(Runnable onCancel) {
-        this.onCancel = Optional.of(onCancel);
-        return this;
-    }
-
-    @Override
-    public void request(long n) {
-        this.onRequest.ifPresent(c -> c.accept(n));
-    }
-
-    @Override
-    public void cancel() {
-        this.onCancel.ifPresent(Runnable::run);
-    }
-}
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index d55ac370d57..af5e4eb838e 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -29,7 +29,7 @@
 import java.util.stream.LongStream;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.common.reactive.TappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
index bad4f6ce459..2cf8791a97d 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
@@ -28,7 +28,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.LongStream;
 
-import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.common.reactive.TappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
index 7f802a52c67..40a506f9965 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
@@ -18,7 +18,7 @@
 package io.helidon.microrofile.reactive;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.microprofile.reactive.TappedProcessor;
+import io.helidon.common.reactive.TappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.reactivestreams.Processor;

From 5ed330d9a7588385864653c427a91706e93f45d6 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 27 Dec 2019 17:21:38 +0100
Subject: [PATCH 56/66] Move RS augments to BaseProcessor

Signed-off-by: Daniel Kec 
---
 .../BackPressureOverflowException.java        |  9 ++
 .../common/reactive/BaseProcessor.java        | 96 ++++++++++++++-----
 .../common/reactive/BufferedProcessor.java    | 93 ++----------------
 .../common/reactive/DropWhileProcessor.java   |  5 +
 .../common/reactive/LimitProcessor.java       |  2 +-
 .../io/helidon/common/reactive/Multi.java     | 16 +++-
 .../reactive/OnErrorResumeProcessor.java      | 44 ++++++---
 .../common/reactive/TakeWhileProcessor.java   | 10 ++
 .../common/reactive/BaseProcessorTest.java    |  2 +
 .../reactive/CoupledProcessorTest.java        | 68 -------------
 10 files changed, 154 insertions(+), 191 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
index 3a3154384f8..a1c329af6ab 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
@@ -17,7 +17,16 @@
 
 package io.helidon.common.reactive;
 
+/**
+ * Raised when back-pressure buffer overflows.
+ */
 public class BackPressureOverflowException extends Exception {
+
+    /**
+     * Create new {@link BackPressureOverflowException}.
+     *
+     * @param limit Overflown limit
+     */
     public BackPressureOverflowException(int limit) {
         super(String.format("Buffer limit %d exceeded.", limit));
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 9e04223e83f..4f97dd259b3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -19,8 +19,10 @@
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * A generic processor used for the implementation of {@link Multi} and {@link Single}.
@@ -35,8 +37,10 @@ public abstract class BaseProcessor implements Processor, Subscripti
     private final RequestedCounter requested;
     private final AtomicBoolean ready;
     private final AtomicBoolean subscribed;
-    protected volatile boolean done;
-    protected Throwable error;
+    private SubscriberReference referencedSubscriber;
+    private ReentrantLock publisherSequentialLock = new ReentrantLock();
+    private volatile boolean done;
+    private Throwable error;
 
     /**
      * Generic processor used for the implementation of {@link Multi} and {@link Single}.
@@ -50,7 +54,9 @@ public BaseProcessor() {
 
     @Override
     public void request(long n) {
-        requested.increment(n, this::fail);
+        StreamValidationUtils.checkRequestParam309(n, this::failAndCancel);
+        StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> failAndCancel(t));
+        requested.increment(n, this::failAndCancel);
         tryRequest(subscription);
         if (done) {
             tryComplete();
@@ -63,37 +69,56 @@ public void cancel() {
         try {
             hookOnCancel(subscription);
         } catch (Throwable ex) {
-            fail(ex);
+            failAndCancel(ex);
         }
     }
 
     @Override
     public void onSubscribe(Subscription s) {
-        if (subscription == null) {
-            this.subscription = s;
-            tryRequest(s);
+        try {
+            // https://github.com/reactive-streams/reactive-streams-jvm#1.3
+            publisherSequentialLock.lock();
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+            Objects.requireNonNull(s);
+            if (subscription == null) {
+                this.subscription = s;
+                tryRequest(s);
+            } else {
+                // https://github.com/reactive-streams/reactive-streams-jvm#2.5
+                s.cancel();
+            }
+        } finally {
+            publisherSequentialLock.unlock();
         }
     }
 
     @Override
     public void onNext(T item) {
-        if (subscriber.isClosed()) {
-            throw new IllegalStateException("Subscriber is closed!");
-        }
         try {
-            hookOnNext(item);
-        } catch (Throwable ex) {
-            fail(ex);
+            publisherSequentialLock.lock();
+            if (done) {
+                throw new IllegalStateException("Subscriber is closed!");
+            }
+            // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+            Objects.requireNonNull(item);
+            try {
+                hookOnNext(item);
+            } catch (Throwable ex) {
+                failAndCancel(ex);
+            }
+        } finally {
+            publisherSequentialLock.unlock();
         }
     }
 
     /**
-     * Proxy caller of {@link BaseProcessor#onError(java.lang.Throwable)} to avoid
-     * https://github.com/reactive-streams/reactive-streams-jvm#2.3c .
+     * OnError downstream.
      *
      * @param ex Exception to be reported downstream
      */
     protected void fail(Throwable ex) {
+        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
+        Objects.requireNonNull(ex);
         done = true;
         if (error == null) {
             error = ex;
@@ -101,6 +126,16 @@ protected void fail(Throwable ex) {
         tryComplete();
     }
 
+    /**
+     * OnError downstream and cancel upstream.
+     *
+     * @param ex Exception to be reported downstream
+     */
+    protected void failAndCancel(Throwable ex) {
+        getSubscription().ifPresent(Flow.Subscription::cancel);
+        fail(ex);
+    }
+
     @Override
     public void onError(Throwable ex) {
         fail(ex);
@@ -114,12 +149,19 @@ public void onComplete() {
 
     @Override
     public void subscribe(Subscriber s) {
-        if (subscriber.register(s)) {
-            ready.set(true);
-            s.onSubscribe(this);
-            if (done) {
-                tryComplete();
+        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
+        referencedSubscriber = SubscriberReference.create(s);
+        try {
+            publisherSequentialLock.lock();
+            if (subscriber.register(s)) {
+                ready.set(true);
+                s.onSubscribe(this);
+                if (done) {
+                    tryComplete();
+                }
             }
+        } finally {
+            publisherSequentialLock.unlock();
         }
     }
 
@@ -162,15 +204,20 @@ protected void submit(U item) {
                 subscriber.get().onNext(item);
             } catch (InterruptedException ex) {
                 Thread.currentThread().interrupt();
-                fail(ex);
+                failAndCancel(ex);
             } catch (Throwable ex) {
-                fail(ex);
+                failAndCancel(ex);
             }
         } else {
             notEnoughRequest(item);
         }
     }
 
+    /**
+     * Define what to do when there is not enough requests to submit item.
+     *
+     * @param item Item for submitting
+     */
     protected void notEnoughRequest(U item) {
         onError(new IllegalStateException("Not enough request to submit item"));
     }
@@ -203,6 +250,9 @@ protected void hookOnComplete() {
      * @param subscription of the processor for optional passing cancel event
      */
     protected void hookOnCancel(Flow.Subscription subscription) {
+        Optional.ofNullable(subscription).ifPresent(Flow.Subscription::cancel);
+        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
+        referencedSubscriber.releaseReference();
     }
 
     /**
@@ -225,7 +275,7 @@ public void onNext(U item) {
 
                 @Override
                 public void onError(Throwable ex) {
-                    BaseProcessor.this.fail(ex);
+                    BaseProcessor.this.failAndCancel(ex);
                 }
 
                 @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index 25ba6c7c43f..b6ed6aa5bc0 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -17,27 +17,20 @@
 
 package io.helidon.common.reactive;
 
-import java.util.Objects;
-import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.locks.ReentrantLock;
 
-public class BufferedProcessor extends BaseProcessor {
+/**
+ * Processor with back-pressure buffer.
+ *
+ * @param  subscribed type (input)
+ * @param  published type (output)
+ */
+public abstract class BufferedProcessor extends BaseProcessor {
 
     private static final int BACK_PRESSURE_BUFFER_SIZE = 1024;
 
-    private SubscriberReference referencedSubscriber;
     private BlockingQueue buffer = new ArrayBlockingQueue(BACK_PRESSURE_BUFFER_SIZE);
-    private ReentrantLock publisherSequentialLock = new ReentrantLock();
-
-    @Override
-    public void request(long n) {
-        //TODO: Move to BaseProcessor
-        StreamValidationUtils.checkRequestParam309(n, this::fail);
-        StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> fail(t));
-        super.request(n);
-    }
 
     @Override
     protected void tryRequest(Flow.Subscription subscription) {
@@ -45,58 +38,13 @@ protected void tryRequest(Flow.Subscription subscription) {
             try {
                 submit(buffer.take());
             } catch (InterruptedException e) {
-                fail(e);
+                failAndCancel(e);
             }
         } else {
             super.tryRequest(subscription);
         }
     }
 
-    @Override
-    public void subscribe(Flow.Subscriber s) {
-        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
-        //TODO: Move to BaseProcessor
-        referencedSubscriber = SubscriberReference.create(s);
-        publisherSequentialLock.lock();
-        super.subscribe(referencedSubscriber);
-        publisherSequentialLock.unlock();
-    }
-
-    @Override
-    protected void hookOnCancel(Flow.Subscription subscription) {
-        //TODO: Move to BaseProcessor
-        Optional.ofNullable(subscription).ifPresent(Flow.Subscription::cancel);
-        // https://github.com/reactive-streams/reactive-streams-jvm#3.13
-        referencedSubscriber.releaseReference();
-    }
-
-    @Override
-    public void onNext(T item) {
-        //TODO: Move to BaseProcessor
-        publisherSequentialLock.lock();
-        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-        Objects.requireNonNull(item);
-        try {
-            hookOnNext(item);
-        } catch (Throwable ex) {
-            fail(ex);
-        }
-        publisherSequentialLock.unlock();
-    }
-
-    @Override
-    //TODO: Move to BaseProcessor
-    public void onSubscribe(Flow.Subscription s) {
-        // https://github.com/reactive-streams/reactive-streams-jvm#1.3
-        publisherSequentialLock.lock();
-        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-        Objects.requireNonNull(s);
-        // https://github.com/reactive-streams/reactive-streams-jvm#2.5
-        getSubscription().ifPresent(firstSubscription -> s.cancel());
-        super.onSubscribe(s);
-        publisherSequentialLock.unlock();
-    }
-
     @Override
     protected void notEnoughRequest(U item) {
         if (!buffer.offer(item)) {
@@ -110,29 +58,4 @@ public void onComplete() {
             super.onComplete();
         }
     }
-
-    @Override
-    //TODO: Move to BaseProcessor
-    public void fail(Throwable ex) {
-        //Upstream cancel on error with fail method proxy to avoid spec rule 2.3
-        getSubscription().ifPresent(Flow.Subscription::cancel);
-        super.fail(ex);
-    }
-
-    @Override
-    //TODO: Move to BaseProcessor
-    public void onError(Throwable ex) {
-        superOnError(ex);
-    }
-
-    //TODO: Move to BaseProcessor
-    protected void superOnError(Throwable ex) {
-        // https://github.com/reactive-streams/reactive-streams-jvm#2.13
-        Objects.requireNonNull(ex);
-        done = true;
-        if (error == null) {
-            error = ex;
-        }
-        tryComplete();
-    }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
index 3ec9eb15392..e0139e52952 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
@@ -19,6 +19,11 @@
 
 import java.util.function.Predicate;
 
+/**
+ * Drop the longest prefix of elements from this stream that satisfy the given predicate.
+ *
+ * @param  Item type
+ */
 public class DropWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
index fa6d6a135e2..4d2c764053d 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
@@ -49,7 +49,7 @@ public void subscribe(Flow.Subscriber s) {
     public void onError(Throwable ex) {
         if (0 < this.counter.get()) {
             super.onError(ex);
-        }else {
+        } else {
             tryComplete();
         }
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 8aff3046094..df42271a123 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -132,6 +132,7 @@ default Multi skip(long skip) {
 
     /**
      * Coupled processor sends items received to the passed in subscriber, and emits items received from the passed in publisher.
+     * Cancel, onComplete and onError signals are shared.
      * 
          *     +
      *     |  Inlet/upstream publisher
@@ -146,7 +147,6 @@ default Multi skip(long skip) {
      *     v
      * 
    
      *
-     * @param                 Inlet and passed in subscriber item type
      * @param                 Outlet and passed in publisher item type
      * @param passedInSubscriber gets all items from upstream/inlet
      * @param passedInPublisher  emits to downstream/outlet
@@ -211,6 +211,12 @@ default Multi onErrorResume(Function onError) {
         return processor;
     }
 
+    /**
+     * Resume stream from supplied publisher if onError signal is intercepted.
+     *
+     * @param onError supplier of new stream publisher
+     * @return Multi
+     */
     default Multi onErrorResumeWith(Function> onError) {
         OnErrorResumeProcessor processor = OnErrorResumeProcessor.resumeWith(onError);
         this.subscribe(processor);
@@ -348,6 +354,14 @@ static  Multi never() {
         return MultiNever.instance();
     }
 
+    /**
+     * Concat streams to one.
+     *
+     * @param firstMulti  first stream
+     * @param secondMulti second stream
+     * @param          item type
+     * @return Multi
+     */
     static  Multi concat(Multi firstMulti, Multi secondMulti) {
         return new ConcatPublisher<>(firstMulti, secondMulti);
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
index 3234a63d732..d8a0b2bf5d1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
@@ -19,18 +19,30 @@
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 
+/**
+ * Resume stream from supplied publisher if onError signal is intercepted.
+ *
+ * @param  item type
+ */
 public class OnErrorResumeProcessor extends BufferedProcessor implements Multi {
 
     private Function supplier;
     private Function> publisherSupplier;
-    //TODO: sync access - onError can do async write?
-    private Optional onErrorPublisherSubscription = Optional.empty();
+    private AtomicReference> onErrorPublisherSubscription = new AtomicReference<>(Optional.empty());
 
     private OnErrorResumeProcessor() {
     }
 
+    /**
+     * Create new {@link OnErrorResumeProcessor} with supplier for item to submit after error is intercepted.
+     *
+     * @param supplier for item to submit after error is intercepted
+     * @param       item type
+     * @return new {@link OnErrorResumeProcessor}
+     */
     @SuppressWarnings("unchecked")
     public static  OnErrorResumeProcessor resume(Function supplier) {
         OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
@@ -38,6 +50,15 @@ public static  OnErrorResumeProcessor resume(Function suppli
         return processor;
     }
 
+    /**
+     * Create new {@link OnErrorResumeProcessor} with supplier for {@link io.helidon.common.reactive.Flow.Publisher}
+     * to resume stream after error is intercepted.
+     *
+     * @param supplier or {@link io.helidon.common.reactive.Flow.Publisher}
+     *                 to resume stream after error is intercepted
+     * @param       item type
+     * @return new {@link OnErrorResumeProcessor}
+     */
     public static  OnErrorResumeProcessor resumeWith(Function> supplier) {
         OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
         processor.publisherSupplier = supplier;
@@ -46,11 +67,8 @@ public static  OnErrorResumeProcessor resumeWith(Function 0) {
                             subscription.request(getRequestedCounter().get());
                         }
@@ -87,25 +105,25 @@ public void onNext(T t) {
                     @Override
                     public void onError(Throwable t) {
                         Objects.requireNonNull(t);
-                        superOnError(t);
+                        fail(t);
                     }
 
                     @Override
                     public void onComplete() {
                         OnErrorResumeProcessor.this.onComplete();
-                        onErrorPublisherSubscription = Optional.empty();
+                        onErrorPublisherSubscription.set(Optional.empty());
                     }
                 });
             }
         } catch (Throwable t) {
-            onErrorPublisherSubscription.ifPresent(Flow.Subscription::cancel);
-            superOnError(t);
+            onErrorPublisherSubscription.get().ifPresent(Flow.Subscription::cancel);
+            fail(t);
         }
     }
 
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         subscription.cancel();
-        onErrorPublisherSubscription.ifPresent(Flow.Subscription::cancel);
+        onErrorPublisherSubscription.get().ifPresent(Flow.Subscription::cancel);
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
index 2f053e339bb..7e689ca065c 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
@@ -19,9 +19,19 @@
 
 import java.util.function.Predicate;
 
+/**
+ * Take the longest prefix of elements from this stream that satisfy the given predicate.
+ *
+ * @param   Item type
+ */
 public class TakeWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
+    /**
+     * Create new {@link TakeWhileProcessor}.
+     *
+     * @param predicate provided predicate to filter stream with
+     */
     public TakeWhileProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
index c64ac45a612..b10557a3a09 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
@@ -19,6 +19,7 @@
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -237,6 +238,7 @@ public void testDoubleSubscribe() {
     }
 
     @Test
+    @Disabled("Against https://github.com/reactive-streams/reactive-streams-jvm#2.5")
     public void testSubscriptionNotCanceled() {
         TestProcessor processor = new TestProcessor<>();
         TestSubscription subscription = new TestSubscription();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
index 2cf8791a97d..930f903bbdc 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CancellationException;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -156,71 +155,4 @@ public void onComplete() {
         //is cancelled afe
         assertThrows(CancellationException.class, () -> completionStage.toCompletableFuture().get(3, TimeUnit.SECONDS));
     }
-
-    @Test
-    void spec203() throws InterruptedException, ExecutionException, TimeoutException {
-
-        Processor processor = ReactiveStreams
-                .coupled(
-                        ReactiveStreams.builder().ignore(),
-                        ReactiveStreams.fromPublisher(new Publisher() {
-                            @Override
-                            public void subscribe(Subscriber s) {
-                                s.onSubscribe(new Subscription() {
-                                    @Override
-                                    public void request(long n) {
-                                        System.out.println("Request called");
-                                        s.onNext(4L);
-                                    }
-
-                                    @Override
-                                    public void cancel() {
-                                        System.out.println("Cancel called");
-                                        Throwable thr = new Throwable();
-                                        for (StackTraceElement stackElem : thr.getStackTrace()) {
-                                            if (stackElem.getMethodName().equals("onError")) {
-                                                System.out.println(String.format("Subscription::cancel MUST NOT be called from Subscriber::onError (Rule 2.3)! (Caller: %s::%s line %d)",
-                                                        stackElem.getClassName(), stackElem.getMethodName(), stackElem.getLineNumber()));
-                                            }
-                                        }
-                                    }
-                                });
-                                s.onComplete();
-                            }
-                        })
-                )
-                .buildRs();
-
-        List result = ReactiveStreams
-                .of(1L, 2L)
-                .peek(l -> {
-                    throw new TestRuntimeException();
-                })
-                .via(processor)
-                .toList()
-                .run()
-                .toCompletableFuture()
-                .get(1, TimeUnit.SECONDS);
-
-        System.out.println(result);
-    }
-
-    String ctx = "Wheee ctx";
-
-    @Test
-    void name() {
-        CompletableFuture test = new CompletableFuture<>();
-
-        testMethod1(test);
-        testMethod2(test);
-
-    }
-
-    private void testMethod1(CompletableFuture test) {
-        test.complete(Thread.currentThread().getStackTrace()[2].getMethodName());
-    }
-
-    private void testMethod2(CompletableFuture test) {
-        test.thenAccept(x -> System.out.println(x + ctx));
-    }
 }

From 31e045d6c4a6f23c9f9c7eaa9462e866fd858b03 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 27 Dec 2019 18:43:15 +0100
Subject: [PATCH 57/66] Checkstyle cleanup of common module

Signed-off-by: Daniel Kec 
---
 .../common/reactive/ConcatPublisher.java      | 12 +++-
 .../common/reactive/FailedPublisher.java      | 10 +++
 .../io/helidon/common/reactive/Multi.java     | 24 +++----
 .../reactive/MultiCoupledProcessor.java       |  7 +-
 ...essor.java => MultiDistinctProcessor.java} | 12 +++-
 ...ssor.java => MultiDropWhileProcessor.java} |  4 +-
 ...ocessor.java => MultiFilterProcessor.java} |  4 +-
 .../reactive/MultiFlatMapProcessor.java       | 72 +++++++++++--------
 ...rocessor.java => MultiLimitProcessor.java} |  4 +-
 ....java => MultiOnErrorResumeProcessor.java} | 22 +++---
 ...Processor.java => MultiPeekProcessor.java} |  4 +-
 ...Processor.java => MultiSkipProcessor.java} | 11 ++-
 ...ssor.java => MultiTakeWhileProcessor.java} |  6 +-
 ...ocessor.java => MultiTappedProcessor.java} | 26 +++----
 .../helidon/common/reactive/OfPublisher.java  | 10 +++
 .../common/reactive/SubscriberReference.java  |  2 +-
 .../io/helidon/common/reactive/MultiTest.java |  4 +-
 .../reactive/CumulativeProcessor.java         |  4 +-
 .../microprofile/reactive/GraphBuilder.java   | 42 +++++------
 .../reactive/AbstractProcessorTest.java       |  4 +-
 .../reactive/CoupledProcessorTest.java        |  4 +-
 .../microrofile/reactive/EngineTest.java      | 20 +++---
 ....java => MultiDropWhileProcessorTest.java} |  2 +-
 ...est.java => MultiFilterProcessorTest.java} |  2 +-
 ...Test.java => MultiLimitProcessorTest.java} |  2 +-
 ...a => MultiOnErrorResumeProcessorTest.java} |  2 +-
 ...rTest.java => MultiPeekProcessorTest.java} |  2 +-
 ...rTest.java => MultiSkipProcessorTest.java} |  2 +-
 ....java => MultiTakeWhileProcessorTest.java} |  2 +-
 ...est.java => MultiTappedProcessorTest.java} |  8 +--
 30 files changed, 197 insertions(+), 133 deletions(-)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{DistinctProcessor.java => MultiDistinctProcessor.java} (81%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{DropWhileProcessor.java => MultiDropWhileProcessor.java} (90%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{FilterProcessor.java => MultiFilterProcessor.java} (89%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{LimitProcessor.java => MultiLimitProcessor.java} (93%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{OnErrorResumeProcessor.java => MultiOnErrorResumeProcessor.java} (79%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{PeekProcessor.java => MultiPeekProcessor.java} (89%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{SkipProcessor.java => MultiSkipProcessor.java} (81%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{TakeWhileProcessor.java => MultiTakeWhileProcessor.java} (85%)
 rename common/reactive/src/main/java/io/helidon/common/reactive/{TappedProcessor.java => MultiTappedProcessor.java} (79%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{DropWhileProcessorTest.java => MultiDropWhileProcessorTest.java} (94%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{FilterProcessorTest.java => MultiFilterProcessorTest.java} (94%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{LimitProcessorTest.java => MultiLimitProcessorTest.java} (97%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{OnErrorResumeProcessorTest.java => MultiOnErrorResumeProcessorTest.java} (98%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{PeekProcessorTest.java => MultiPeekProcessorTest.java} (94%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{SkipProcessorTest.java => MultiSkipProcessorTest.java} (96%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{TakeWhileProcessorTest.java => MultiTakeWhileProcessorTest.java} (95%)
 rename microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/{TappedProcessorTest.java => MultiTappedProcessorTest.java} (81%)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
index 909796feb36..ac5d752196f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
@@ -21,6 +21,11 @@
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
 
+/**
+ * Concat streams to one.
+ *
+ * @param  item type
+ */
 public class ConcatPublisher implements Flow.Publisher, Multi {
     private FirstProcessor firstProcessor;
     private SecondProcessor secondProcessor;
@@ -29,7 +34,12 @@ public class ConcatPublisher implements Flow.Publisher, Multi {
     private Flow.Publisher secondPublisher;
     private AtomicLong requested = new AtomicLong();
 
-
+    /**
+     * Create new {@link ConcatPublisher}.
+     *
+     * @param firstPublisher  first stream
+     * @param secondPublisher second stream
+     */
     public ConcatPublisher(Flow.Publisher firstPublisher, Flow.Publisher secondPublisher) {
         this.firstPublisher = firstPublisher;
         this.secondPublisher = secondPublisher;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
index af3f36c2de8..6f35470faf5 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
@@ -17,10 +17,20 @@
 
 package io.helidon.common.reactive;
 
+/**
+ * Stream from {@link FailedPublisher} sends onError signal after onSubscribe is called.
+ *
+ * @param  item type
+ */
 public class FailedPublisher implements Flow.Publisher, Multi {
 
     private Throwable throwable;
 
+    /**
+     * Create new {@link FailedPublisher}.
+     *
+     * @param throwable to fail stream with
+     */
     public FailedPublisher(Throwable throwable) {
         this.throwable = throwable;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index df42271a123..e512f7f050e 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -54,7 +54,7 @@ default  Multi map(Mapper mapper) {
      * @return Multi
      */
     default Multi peek(Consumer consumer) {
-        PeekProcessor processor = new PeekProcessor(consumer);
+        MultiPeekProcessor processor = new MultiPeekProcessor(consumer);
         this.subscribe(processor);
         return processor;
     }
@@ -65,7 +65,7 @@ default Multi peek(Consumer consumer) {
      * @return Multi
      */
     default Multi distinct() {
-        DistinctProcessor processor = new DistinctProcessor<>();
+        MultiDistinctProcessor processor = new MultiDistinctProcessor<>();
         this.subscribe(processor);
         return processor;
     }
@@ -77,7 +77,7 @@ default Multi distinct() {
      * @return Multi
      */
     default Multi filter(Predicate predicate) {
-        FilterProcessor processor = new FilterProcessor<>(predicate);
+        MultiFilterProcessor processor = new MultiFilterProcessor<>(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -89,7 +89,7 @@ default Multi filter(Predicate predicate) {
      * @return Multi
      */
     default Multi takeWhile(Predicate predicate) {
-        TakeWhileProcessor processor = new TakeWhileProcessor<>(predicate);
+        MultiTakeWhileProcessor processor = new MultiTakeWhileProcessor<>(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -101,7 +101,7 @@ default Multi takeWhile(Predicate predicate) {
      * @return Multi
      */
     default Multi dropWhile(Predicate predicate) {
-        DropWhileProcessor processor = new DropWhileProcessor<>(predicate);
+        MultiDropWhileProcessor processor = new MultiDropWhileProcessor<>(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -113,7 +113,7 @@ default Multi dropWhile(Predicate predicate) {
      * @return Multi
      */
     default Multi limit(long limit) {
-        LimitProcessor processor = new LimitProcessor<>(limit);
+        MultiLimitProcessor processor = new MultiLimitProcessor<>(limit);
         this.subscribe(processor);
         return processor;
     }
@@ -125,7 +125,7 @@ default Multi limit(long limit) {
      * @return Multi
      */
     default Multi skip(long skip) {
-        SkipProcessor processor = new SkipProcessor<>(skip);
+        MultiSkipProcessor processor = new MultiSkipProcessor<>(skip);
         this.subscribe(processor);
         return processor;
     }
@@ -165,7 +165,7 @@ default  Multi coupled(Flow.Subscriber passedInSubscriber, Flow.Publish
      * @return Multi
      */
     default Multi onTerminate(Runnable onTerminate) {
-        TappedProcessor processor = TappedProcessor.create()
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
                 .onComplete(onTerminate)
                 .onCancel((s) -> onTerminate.run())
                 .onError((t) -> onTerminate.run());
@@ -180,7 +180,7 @@ default Multi onTerminate(Runnable onTerminate) {
      * @return Multi
      */
     default Multi onComplete(Runnable onTerminate) {
-        TappedProcessor processor = TappedProcessor.create()
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
                 .onComplete(onTerminate);
         this.subscribe(processor);
         return processor;
@@ -193,7 +193,7 @@ default Multi onComplete(Runnable onTerminate) {
      * @return Multi
      */
     default Multi onError(Consumer onErrorConsumer) {
-        TappedProcessor processor = TappedProcessor.create()
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
                 .onError(onErrorConsumer);
         this.subscribe(processor);
         return processor;
@@ -206,7 +206,7 @@ default Multi onError(Consumer onErrorConsumer) {
      * @return Multi
      */
     default Multi onErrorResume(Function onError) {
-        OnErrorResumeProcessor processor = OnErrorResumeProcessor.resume(onError);
+        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resume(onError);
         this.subscribe(processor);
         return processor;
     }
@@ -218,7 +218,7 @@ default Multi onErrorResume(Function onError) {
      * @return Multi
      */
     default Multi onErrorResumeWith(Function> onError) {
-        OnErrorResumeProcessor processor = OnErrorResumeProcessor.resumeWith(onError);
+        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resumeWith(onError);
         this.subscribe(processor);
         return processor;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
index 50407449ce6..54dc5eddccb 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
@@ -48,10 +48,15 @@ public class MultiCoupledProcessor implements Flow.Processor, Multi<
     private Flow.Subscriber inletSubscriber;
     private Flow.Subscription inletSubscription;
     private Flow.Subscription passedInPublisherSubscription;
-
     private AtomicBoolean cancelled = new AtomicBoolean(false);
 
 
+    /**
+     * Create new {@link MultiCoupledProcessor}.
+     *
+     * @param passedInSubscriber to send items from inlet to
+     * @param passedInPublisher  to get items for outlet from
+     */
     public MultiCoupledProcessor(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
         this.passedInSubscriber = SubscriberReference.create(passedInSubscriber);
         this.passedInPublisher = passedInPublisher;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
similarity index 81%
rename from common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
index 4cff7af9942..44738c233fe 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
@@ -19,10 +19,18 @@
 
 import java.util.HashSet;
 
-public class DistinctProcessor extends BufferedProcessor implements Multi {
+/**
+ * Filter out all duplicate items.
+ *
+ * @param  item type
+ */
+public class MultiDistinctProcessor extends BufferedProcessor implements Multi {
     private final HashSet distinctSet;
 
-    public DistinctProcessor() {
+    /**
+     * Create new {@link MultiDistinctProcessor}.
+     */
+    public MultiDistinctProcessor() {
         this.distinctSet = new HashSet();
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
similarity index 90%
rename from common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
index e0139e52952..88bd10e5ee8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/DropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  Item type
  */
-public class DropWhileProcessor extends BufferedProcessor implements Multi {
+public class MultiDropWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
     private boolean foundNotMatching = false;
@@ -34,7 +34,7 @@ public class DropWhileProcessor extends BufferedProcessor implements Mu
      *
      * @param predicate provided predicate to filter stream with
      */
-    public DropWhileProcessor(Predicate predicate) {
+    public MultiDropWhileProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
similarity index 89%
rename from common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
index 1777f6eb582..7f55c3e3fab 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class FilterProcessor extends BufferedProcessor implements Multi {
+public class MultiFilterProcessor extends BufferedProcessor implements Multi {
 
     private Predicate predicate;
 
@@ -33,7 +33,7 @@ public class FilterProcessor extends BufferedProcessor implements Multi
      *
      * @param predicate provided predicate to filter stream with
      */
-    public FilterProcessor(Predicate predicate) {
+    public MultiFilterProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index f3e14a0be4b..b1920f508b2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -26,37 +26,51 @@
 
 /**
  * Flatten the elements emitted by publishers produced by the mapper function to this stream.
+ *
+ * @param  item type
  */
-public class MultiFlatMapProcessor implements Flow.Processor, Multi {
+public class MultiFlatMapProcessor implements Flow.Processor, Multi {
 
-    private Function> mapper;
-    private SubscriberReference subscriber;
+    private Function> mapper;
+    private SubscriberReference subscriber;
     private Flow.Subscription subscription;
     private RequestedCounter requestCounter = new RequestedCounter();
     private Flow.Subscription innerSubscription;
     private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
-
-    private PublisherBuffer buffer;
-
+    private PublisherBuffer buffer;
     private Optional error = Optional.empty();
 
     private MultiFlatMapProcessor() {
-        buffer = new PublisherBuffer();
+        buffer = new PublisherBuffer<>();
     }
 
+    /**
+     * Create new {@link MultiFlatMapProcessor} with item to {@link java.lang.Iterable} mapper.
+     *
+     * @param mapper to provide iterable for every item from upstream
+     * @param     item type
+     * @return {@link MultiFlatMapProcessor}
+     */
     @SuppressWarnings("unchecked")
-    public static MultiFlatMapProcessor fromIterableMapper(Function> mapper) {
+    public static  MultiFlatMapProcessor fromIterableMapper(Function> mapper) {
         Function> iterableMapper = (Function>) mapper;
-        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
-        flatMapProcessor.mapper = o -> (Multi) Multi.from(iterableMapper.apply(o));
+        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor<>();
+        flatMapProcessor.mapper = o -> (Multi) Multi.from(iterableMapper.apply(o));
         return flatMapProcessor;
     }
 
+    /**
+     * Create new {@link MultiFlatMapProcessor} with item to {@link io.helidon.common.reactive.Flow.Publisher} mapper.
+     *
+     * @param mapper to provide iterable for every item from upstream
+     * @param     item type
+     * @return {@link MultiFlatMapProcessor}
+     */
     @SuppressWarnings("unchecked")
-    public static MultiFlatMapProcessor fromPublisherMapper(Function> mapper) {
-        Function> publisherMapper = (Function>) mapper;
-        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
-        flatMapProcessor.mapper = publisherMapper;
+    public static  MultiFlatMapProcessor fromPublisherMapper(Function> mapper) {
+        Function> publisherMapper = (Function>) mapper;
+        MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
+        flatMapProcessor.mapper = t -> (Flow.Publisher) publisherMapper.apply(t);
         return flatMapProcessor;
     }
 
@@ -82,7 +96,7 @@ public void cancel() {
     }
 
     @Override
-    public void subscribe(Flow.Subscriber subscriber) {
+    public void subscribe(Flow.Subscriber subscriber) {
         this.subscriber = SubscriberReference.create(subscriber);
         if (Objects.nonNull(this.subscription)) {
             subscriber.onSubscribe(new FlatMapSubscription());
@@ -103,7 +117,7 @@ public void onSubscribe(Flow.Subscription subscription) {
     }
 
     @Override
-    public void onNext(Object o) {
+    public void onNext(T o) {
         Objects.requireNonNull(o);
         buffer.offer(o);
     }
@@ -125,16 +139,16 @@ public void onComplete() {
         }
     }
 
-    private class PublisherBuffer {
-        private BlockingQueue buffer = new ArrayBlockingQueue<>(64);
-        private InnerSubscriber lastSubscriber = null;
+    private class PublisherBuffer {
+        private BlockingQueue buffer = new ArrayBlockingQueue<>(64);
+        private InnerSubscriber lastSubscriber = null;
 
         public boolean isComplete() {
             return Objects.isNull(lastSubscriber) || (lastSubscriber.isDone() && buffer.isEmpty());
         }
 
         public void tryNext() {
-            Object nextItem = buffer.poll();
+            U nextItem = buffer.poll();
             if (Objects.nonNull(nextItem)) {
                 lastSubscriber = executeMapper(nextItem);
             } else if (onCompleteReceivedAlready.get()) {
@@ -143,7 +157,7 @@ public void tryNext() {
             }
         }
 
-        public void offer(Object o) {
+        public void offer(U o) {
             if (buffer.isEmpty() && (Objects.isNull(lastSubscriber) || lastSubscriber.isDone())) {
                 lastSubscriber = executeMapper(o);
             } else {
@@ -151,12 +165,13 @@ public void offer(Object o) {
             }
         }
 
-        public InnerSubscriber executeMapper(Object item) {
-            InnerSubscriber innerSubscriber = null;
+        @SuppressWarnings("unchecked")
+        public InnerSubscriber executeMapper(U item) {
+            InnerSubscriber innerSubscriber = null;
             try {
-                innerSubscriber = new InnerSubscriber();
+                innerSubscriber = new InnerSubscriber<>();
                 innerSubscriber.whenComplete(this::tryNext);
-                mapper.apply(item).subscribe(innerSubscriber);
+                mapper.apply((T) item).subscribe(innerSubscriber);
             } catch (Throwable t) {
                 subscription.cancel();
                 subscriber.onError(t);
@@ -165,7 +180,7 @@ public InnerSubscriber executeMapper(Object item) {
         }
     }
 
-    private class InnerSubscriber implements Flow.Subscriber {
+    private class InnerSubscriber implements Flow.Subscriber {
 
         private AtomicBoolean subscriptionAcked = new AtomicBoolean(false);
         private AtomicBoolean done = new AtomicBoolean(false);
@@ -188,9 +203,10 @@ public void onSubscribe(Flow.Subscription innerSubscription) {
         }
 
         @Override
-        public void onNext(Object o) {
+        @SuppressWarnings("unchecked")
+        public void onNext(R o) {
             Objects.requireNonNull(o);
-            MultiFlatMapProcessor.this.subscriber.onNext(o);
+            MultiFlatMapProcessor.this.subscriber.onNext((T) o);
             requestCounter.tryDecrement();
             long requestCount = requestCounter.get();
             if (requestCount > 0) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
similarity index 93%
rename from common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
index 4d2c764053d..58bab9e9600 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/LimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class LimitProcessor extends BufferedProcessor implements Multi {
+public class MultiLimitProcessor extends BufferedProcessor implements Multi {
 
     private final AtomicLong counter;
 
@@ -33,7 +33,7 @@ public class LimitProcessor extends BufferedProcessor implements Multi<
      *
      * @param limit number of items to pass
      */
-    public LimitProcessor(Long limit) {
+    public MultiLimitProcessor(Long limit) {
         counter = new AtomicLong(limit);
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
similarity index 79%
rename from common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
index d8a0b2bf5d1..26f3df21b5d 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OnErrorResumeProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
@@ -27,40 +27,40 @@
  *
  * @param  item type
  */
-public class OnErrorResumeProcessor extends BufferedProcessor implements Multi {
+public class MultiOnErrorResumeProcessor extends BufferedProcessor implements Multi {
 
     private Function supplier;
     private Function> publisherSupplier;
     private AtomicReference> onErrorPublisherSubscription = new AtomicReference<>(Optional.empty());
 
-    private OnErrorResumeProcessor() {
+    private MultiOnErrorResumeProcessor() {
     }
 
     /**
-     * Create new {@link OnErrorResumeProcessor} with supplier for item to submit after error is intercepted.
+     * Create new {@link MultiOnErrorResumeProcessor} with supplier for item to submit after error is intercepted.
      *
      * @param supplier for item to submit after error is intercepted
      * @param       item type
-     * @return new {@link OnErrorResumeProcessor}
+     * @return new {@link MultiOnErrorResumeProcessor}
      */
     @SuppressWarnings("unchecked")
-    public static  OnErrorResumeProcessor resume(Function supplier) {
-        OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
+    public static  MultiOnErrorResumeProcessor resume(Function supplier) {
+        MultiOnErrorResumeProcessor processor = new MultiOnErrorResumeProcessor<>();
         processor.supplier = (Function) supplier;
         return processor;
     }
 
     /**
-     * Create new {@link OnErrorResumeProcessor} with supplier for {@link io.helidon.common.reactive.Flow.Publisher}
+     * Create new {@link MultiOnErrorResumeProcessor} with supplier for {@link io.helidon.common.reactive.Flow.Publisher}
      * to resume stream after error is intercepted.
      *
      * @param supplier or {@link io.helidon.common.reactive.Flow.Publisher}
      *                 to resume stream after error is intercepted
      * @param       item type
-     * @return new {@link OnErrorResumeProcessor}
+     * @return new {@link MultiOnErrorResumeProcessor}
      */
-    public static  OnErrorResumeProcessor resumeWith(Function> supplier) {
-        OnErrorResumeProcessor processor = new OnErrorResumeProcessor<>();
+    public static  MultiOnErrorResumeProcessor resumeWith(Function> supplier) {
+        MultiOnErrorResumeProcessor processor = new MultiOnErrorResumeProcessor<>();
         processor.publisherSupplier = supplier;
         return processor;
     }
@@ -110,7 +110,7 @@ public void onError(Throwable t) {
 
                     @Override
                     public void onComplete() {
-                        OnErrorResumeProcessor.this.onComplete();
+                        MultiOnErrorResumeProcessor.this.onComplete();
                         onErrorPublisherSubscription.set(Optional.empty());
                     }
                 });
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
similarity index 89%
rename from common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
index d2d24a67a2c..ed5c36e8ff6 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/PeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
@@ -24,7 +24,7 @@
  *
  * @param  both input/output type
  */
-public class PeekProcessor extends BufferedProcessor implements Multi {
+public class MultiPeekProcessor extends BufferedProcessor implements Multi {
 
     private Consumer consumer;
 
@@ -33,7 +33,7 @@ public class PeekProcessor extends BufferedProcessor implements Multi consumer) {
+    public MultiPeekProcessor(Consumer consumer) {
         this.consumer = consumer;
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
similarity index 81%
rename from common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
index e9f43954598..6ee3fc6b2df 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
@@ -19,16 +19,21 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-public class SkipProcessor extends BufferedProcessor implements Multi {
+/**
+ * Skip first n items, all the others are emitted.
+ *
+ * @param  item type
+ */
+public class MultiSkipProcessor extends BufferedProcessor implements Multi {
 
     private final AtomicLong counter;
 
     /**
-     * Processor skips first n items, all the others are emitted.
+     * Create new {@link MultiSkipProcessor}.
      *
      * @param skip number of items to be skipped
      */
-    public SkipProcessor(Long skip) {
+    public MultiSkipProcessor(Long skip) {
         counter = new AtomicLong(skip);
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
similarity index 85%
rename from common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
index 7e689ca065c..59734f267ef 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
@@ -24,15 +24,15 @@
  *
  * @param   Item type
  */
-public class TakeWhileProcessor extends BufferedProcessor implements Multi {
+public class MultiTakeWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
     /**
-     * Create new {@link TakeWhileProcessor}.
+     * Create new {@link MultiTakeWhileProcessor}.
      *
      * @param predicate provided predicate to filter stream with
      */
-    public TakeWhileProcessor(Predicate predicate) {
+    public MultiTakeWhileProcessor(Predicate predicate) {
         this.predicate = predicate;
     }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
similarity index 79%
rename from common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
index b4a9d03f013..1fcd7bb61f3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/TappedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
@@ -26,33 +26,33 @@
  *
  * @param  Type of the processed items.
  */
-public class TappedProcessor extends BufferedProcessor implements Multi {
+public class MultiTappedProcessor extends BufferedProcessor implements Multi {
 
     private Optional> onNextFunction = Optional.empty();
     private Optional> onErrorConsumer = Optional.empty();
     private Optional onCompleteRunnable = Optional.empty();
     private Optional> onCancelConsumer = Optional.empty();
 
-    private TappedProcessor() {
+    private MultiTappedProcessor() {
     }
 
     /**
      * Create new processor with no functions to execute when signals are intercepted.
      *
      * @param  Type of the processed items.
-     * @return Brand new {@link io.helidon.common.reactive.TappedProcessor}
+     * @return Brand new {@link MultiTappedProcessor}
      */
-    public static  TappedProcessor create() {
-        return new TappedProcessor<>();
+    public static  MultiTappedProcessor create() {
+        return new MultiTappedProcessor<>();
     }
 
     /**
      * Set {@link java.util.function.Function} to be executed when onNext signal is intercepted.
      *
      * @param function Function to be invoked.
-     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     * @return This {@link MultiTappedProcessor}
      */
-    public TappedProcessor onNext(Function function) {
+    public MultiTappedProcessor onNext(Function function) {
         onNextFunction = Optional.ofNullable(function);
         return this;
     }
@@ -62,9 +62,9 @@ public TappedProcessor onNext(Function function) {
      *
      * @param consumer Consumer to be executed when onError signal is intercepted,
      *                 argument is intercepted {@link java.lang.Throwable}.
-     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     * @return This {@link MultiTappedProcessor}
      */
-    public TappedProcessor onError(Consumer consumer) {
+    public MultiTappedProcessor onError(Consumer consumer) {
         onErrorConsumer = Optional.ofNullable(consumer);
         return this;
     }
@@ -73,9 +73,9 @@ public TappedProcessor onError(Consumer consumer) {
      * Set {@link java.lang.Runnable} to be executed when onComplete signal is intercepted.
      *
      * @param runnable {@link java.lang.Runnable} to be executed.
-     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     * @return This {@link MultiTappedProcessor}
      */
-    public TappedProcessor onComplete(Runnable runnable) {
+    public MultiTappedProcessor onComplete(Runnable runnable) {
         onCompleteRunnable = Optional.ofNullable(runnable);
         return this;
     }
@@ -85,9 +85,9 @@ public TappedProcessor onComplete(Runnable runnable) {
      *
      * @param consumer Consumer to be executed when onCancel signal is intercepted,
      *                 argument is intercepted {@link io.helidon.common.reactive.Flow.Subscription}.
-     * @return This {@link io.helidon.common.reactive.TappedProcessor}
+     * @return This {@link MultiTappedProcessor}
      */
-    public TappedProcessor onCancel(Consumer consumer) {
+    public MultiTappedProcessor onCancel(Consumer consumer) {
         onCancelConsumer = Optional.ofNullable(consumer);
         return this;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
index eaebc5f6259..961cd28c8a5 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
@@ -22,6 +22,11 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 
+/**
+ * Publisher from iterable, implemented as trampoline stack-less recursion.
+ *
+ * @param  item type
+ */
 public class OfPublisher implements Flow.Publisher {
     private Iterable iterable;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
@@ -30,6 +35,11 @@ public class OfPublisher implements Flow.Publisher {
     private final RequestedCounter requestCounter = new RequestedCounter();
     private final ReentrantLock iterateConcurrentLock = new ReentrantLock();
 
+    /**
+     * Create new {@link OfPublisher}.
+     *
+     * @param iterable to create publisher from
+     */
     public OfPublisher(Iterable iterable) {
         this.iterable = iterable;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
index 940e3c8c18a..47f597eaf3a 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
@@ -19,7 +19,7 @@
 
 import java.util.Optional;
 
-public class SubscriberReference implements Flow.Subscriber {
+class SubscriberReference implements Flow.Subscriber {
     private Optional> subscriber;
 
     private SubscriberReference(Flow.Subscriber subscriber) {
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index a714dfd66cc..8f74f81eb3b 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -368,10 +368,10 @@ void testCoupled() throws ExecutionException, InterruptedException, TimeoutExcep
         final List TEST_DATA = List.of(1, 2, 3, 4, 3, 2, 1, 0);
 
         CountDownLatch countDownLatch = new CountDownLatch(TEST_DATA.size());
-        PeekProcessor peekProcessor = new PeekProcessor<>(i -> countDownLatch.countDown());
+        MultiPeekProcessor multiPeekProcessor = new MultiPeekProcessor<>(i -> countDownLatch.countDown());
 
         List result = Multi.just(TEST_DATA)
-                .coupled(peekProcessor, peekProcessor)
+                .coupled(multiPeekProcessor, multiPeekProcessor)
                 .collectList()
                 .get(1, TimeUnit.SECONDS);
 
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index bdda47ba534..3f53edd00e8 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -23,7 +23,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.TappedProcessor;
+import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.reactivestreams.Processor;
@@ -47,7 +47,7 @@ public class CumulativeProcessor implements Processor {
         //preceding processors
         precedingProcessorList.forEach(fp -> this.processorList.add(HybridProcessor.from(fp)));
         //pass-thru if no processors provided
-        this.processorList.add(HybridProcessor.from(TappedProcessor.create()));
+        this.processorList.add(HybridProcessor.from(MultiTappedProcessor.create()));
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index c4ae9b27a9b..6b47b4f885b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -28,21 +28,21 @@
 import io.helidon.common.reactive.BufferedProcessor;
 import io.helidon.common.reactive.ConcatPublisher;
 import io.helidon.common.reactive.MultiCoupledProcessor;
-import io.helidon.common.reactive.DistinctProcessor;
-import io.helidon.common.reactive.DropWhileProcessor;
+import io.helidon.common.reactive.MultiDistinctProcessor;
+import io.helidon.common.reactive.MultiDropWhileProcessor;
 import io.helidon.common.reactive.FailedPublisher;
-import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.MultiFilterProcessor;
 import io.helidon.common.reactive.MultiFlatMapProcessor;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.LimitProcessor;
+import io.helidon.common.reactive.MultiLimitProcessor;
 import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.MultiMapProcessor;
 import io.helidon.common.reactive.OfPublisher;
-import io.helidon.common.reactive.OnErrorResumeProcessor;
-import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.common.reactive.SkipProcessor;
-import io.helidon.common.reactive.TakeWhileProcessor;
-import io.helidon.common.reactive.TappedProcessor;
+import io.helidon.common.reactive.MultiOnErrorResumeProcessor;
+import io.helidon.common.reactive.MultiPeekProcessor;
+import io.helidon.common.reactive.MultiSkipProcessor;
+import io.helidon.common.reactive.MultiTakeWhileProcessor;
+import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
@@ -91,29 +91,29 @@ private GraphBuilder() {
             addProcessor(new MultiMapProcessor<>(mapper::apply));
         });
         registerStage(Stage.Filter.class, stage -> {
-            addProcessor(new FilterProcessor<>(stage.getPredicate()));
+            addProcessor(new MultiFilterProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.TakeWhile.class, stage -> {
-            addProcessor(new TakeWhileProcessor<>(stage.getPredicate()));
+            addProcessor(new MultiTakeWhileProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.DropWhile.class, stage -> {
-            addProcessor(new DropWhileProcessor<>(stage.getPredicate()));
+            addProcessor(new MultiDropWhileProcessor<>(stage.getPredicate()));
         });
         registerStage(Stage.Peek.class, stage -> {
             Consumer peekConsumer = (Consumer) stage.getConsumer();
-            addProcessor(new PeekProcessor<>(peekConsumer));
+            addProcessor(new MultiPeekProcessor<>(peekConsumer));
         });
         registerStage(Stage.ProcessorStage.class, stage -> {
             addProcessor(stage.getRsProcessor());
         });
         registerStage(Stage.Limit.class, stage -> {
-            addProcessor(new LimitProcessor<>(stage.getLimit()));
+            addProcessor(new MultiLimitProcessor<>(stage.getLimit()));
         });
         registerStage(Stage.Skip.class, stage -> {
-            addProcessor(new SkipProcessor<>(stage.getSkip()));
+            addProcessor(new MultiSkipProcessor<>(stage.getSkip()));
         });
         registerStage(Stage.Distinct.class, stage -> {
-            addProcessor(new DistinctProcessor<>());
+            addProcessor(new MultiDistinctProcessor<>());
         });
         registerStage(Stage.FlatMap.class, stage -> {
             Function> pubMapper = o -> {
@@ -135,24 +135,24 @@ private GraphBuilder() {
             addProcessor(new MultiCoupledProcessor<>(HybridSubscriber.from(subscriber), HybridPublisher.from(publisher)));
         });
         registerStage(Stage.OnTerminate.class, stage -> {
-            addProcessor(TappedProcessor.create()
+            addProcessor(MultiTappedProcessor.create()
                     .onComplete(stage.getAction())
                     .onCancel((s) -> stage.getAction().run())
                     .onError((t) -> stage.getAction().run()));
         });
         registerStage(Stage.OnComplete.class, stage -> {
-            addProcessor(TappedProcessor.create().onComplete(stage.getAction()));
+            addProcessor(MultiTappedProcessor.create().onComplete(stage.getAction()));
         });
         registerStage(Stage.OnError.class, stage -> {
-            addProcessor(TappedProcessor.create().onError(stage.getConsumer()));
+            addProcessor(MultiTappedProcessor.create().onError(stage.getConsumer()));
         });
         registerStage(Stage.OnErrorResume.class, stage -> {
-            addProcessor(OnErrorResumeProcessor.resume(stage.getFunction()));
+            addProcessor(MultiOnErrorResumeProcessor.resume(stage.getFunction()));
         });
         registerStage(Stage.OnErrorResumeWith.class, stage -> {
             Function> publisherSupplier = throwable ->
                     HybridPublisher.from(GraphBuilder.create().from(stage.getFunction().apply(throwable)).getPublisher());
-            addProcessor(OnErrorResumeProcessor.resumeWith(publisherSupplier));
+            addProcessor(MultiOnErrorResumeProcessor.resumeWith(publisherSupplier));
         });
         registerStage(Stage.Cancel.class, stage -> {
             CancelSubscriber cancelSubscriber = new CancelSubscriber<>();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index af5e4eb838e..2c2839d378b 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -29,7 +29,7 @@
 import java.util.stream.LongStream;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.TappedProcessor;
+import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -45,7 +45,7 @@ public abstract class AbstractProcessorTest {
 
     @SuppressWarnings("unchecked")
     protected Processor getProcessor() {
-        Flow.Processor processor = (Flow.Processor) TappedProcessor.create();
+        Flow.Processor processor = (Flow.Processor) MultiTappedProcessor.create();
         return HybridProcessor.from(processor);
     }
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
index 930f903bbdc..82f4c85ec1f 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/CoupledProcessorTest.java
@@ -27,7 +27,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.LongStream;
 
-import io.helidon.common.reactive.TappedProcessor;
+import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -133,7 +133,7 @@ public void onComplete() {
 
             }
         };
-        HybridProcessor tappedProcessor = HybridProcessor.from(TappedProcessor.create());
+        HybridProcessor tappedProcessor = HybridProcessor.from(MultiTappedProcessor.create());
 
         Processor processor = ReactiveStreams
                 .coupled(
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 9ab200d1904..146f3a8e190 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -37,12 +37,12 @@
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 
-import io.helidon.common.reactive.DropWhileProcessor;
-import io.helidon.common.reactive.FilterProcessor;
+import io.helidon.common.reactive.MultiDropWhileProcessor;
+import io.helidon.common.reactive.MultiFilterProcessor;
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.PeekProcessor;
-import io.helidon.common.reactive.SkipProcessor;
-import io.helidon.common.reactive.TakeWhileProcessor;
+import io.helidon.common.reactive.MultiPeekProcessor;
+import io.helidon.common.reactive.MultiSkipProcessor;
+import io.helidon.common.reactive.MultiTakeWhileProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
@@ -819,11 +819,11 @@ void mapOnError() throws InterruptedException, ExecutionException, TimeoutExcept
 
     @Test
     void finiteStream() throws InterruptedException, ExecutionException, TimeoutException {
-        finiteOnCompleteTest(new PeekProcessor<>(integer -> Function.identity()));
-        finiteOnCompleteTest(new FilterProcessor<>(integer -> true));
-        finiteOnCompleteTest(new TakeWhileProcessor<>(integer -> true));
-        finiteOnCompleteTest(new DropWhileProcessor<>(integer -> false));
-        finiteOnCompleteTest(new SkipProcessor<>(0L));
+        finiteOnCompleteTest(new MultiPeekProcessor<>(integer -> Function.identity()));
+        finiteOnCompleteTest(new MultiFilterProcessor<>(integer -> true));
+        finiteOnCompleteTest(new MultiTakeWhileProcessor<>(integer -> true));
+        finiteOnCompleteTest(new MultiDropWhileProcessor<>(integer -> false));
+        finiteOnCompleteTest(new MultiSkipProcessor<>(0L));
     }
 
     @Test
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiDropWhileProcessorTest.java
similarity index 94%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiDropWhileProcessorTest.java
index c3128f9a611..ef700455401 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/DropWhileProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiDropWhileProcessorTest.java
@@ -20,7 +20,7 @@
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Processor;
 
-public class DropWhileProcessorTest extends AbstractProcessorTest {
+public class MultiDropWhileProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().dropWhile(integer -> false).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiFilterProcessorTest.java
similarity index 94%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiFilterProcessorTest.java
index 05e68a4a951..72b217ae906 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/FilterProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiFilterProcessorTest.java
@@ -20,7 +20,7 @@
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Processor;
 
-public class FilterProcessorTest extends AbstractProcessorTest {
+public class MultiFilterProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().filter(i -> true).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiLimitProcessorTest.java
similarity index 97%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiLimitProcessorTest.java
index 840eb6081dd..5cc45baedc2 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/LimitProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiLimitProcessorTest.java
@@ -30,7 +30,7 @@
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 
-public class LimitProcessorTest extends AbstractProcessorTest {
+public class MultiLimitProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().limit(Long.MAX_VALUE).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiOnErrorResumeProcessorTest.java
similarity index 98%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiOnErrorResumeProcessorTest.java
index 9806386b1e5..f14fd760969 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/OnErrorResumeProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiOnErrorResumeProcessorTest.java
@@ -36,7 +36,7 @@
 import org.reactivestreams.Processor;
 import org.reactivestreams.Publisher;
 
-public class OnErrorResumeProcessorTest extends AbstractProcessorTest {
+public class MultiOnErrorResumeProcessorTest extends AbstractProcessorTest {
 
     @Test
     void onErrorResume() throws InterruptedException, ExecutionException, TimeoutException {
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiPeekProcessorTest.java
similarity index 94%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiPeekProcessorTest.java
index 1e1127b58fb..1ffb3ebd6f4 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/PeekProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiPeekProcessorTest.java
@@ -22,7 +22,7 @@
 import org.eclipse.microprofile.reactive.streams.operators.ReactiveStreams;
 import org.reactivestreams.Processor;
 
-public class PeekProcessorTest extends AbstractProcessorTest {
+public class MultiPeekProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().peek(i -> Function.identity()).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiSkipProcessorTest.java
similarity index 96%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiSkipProcessorTest.java
index 3f1b4b537bb..12d4a864788 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/SkipProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiSkipProcessorTest.java
@@ -29,7 +29,7 @@
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 
-public class SkipProcessorTest extends AbstractProcessorTest {
+public class MultiSkipProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().skip(0).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTakeWhileProcessorTest.java
similarity index 95%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTakeWhileProcessorTest.java
index cde07ad7381..b08472f615a 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TakeWhileProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTakeWhileProcessorTest.java
@@ -26,7 +26,7 @@
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Processor;
 
-public class TakeWhileProcessorTest extends AbstractProcessorTest {
+public class MultiTakeWhileProcessorTest extends AbstractProcessorTest {
     @Override
     protected Processor getProcessor() {
         return ReactiveStreams.builder().takeWhile(i -> true).buildRs();
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
similarity index 81%
rename from microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
rename to microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
index 40a506f9965..d886a849f2e 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/TappedProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
@@ -18,23 +18,23 @@
 package io.helidon.microrofile.reactive;
 
 import io.helidon.common.reactive.Flow;
-import io.helidon.common.reactive.TappedProcessor;
+import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.reactivestreams.Processor;
 
-public class TappedProcessorTest extends AbstractProcessorTest {
+public class MultiTappedProcessorTest extends AbstractProcessorTest {
     @Override
     @SuppressWarnings("unchecked")
     protected Processor getProcessor() {
-        Flow.Processor processor = TappedProcessor.create();
+        Flow.Processor processor = MultiTappedProcessor.create();
         return HybridProcessor.from(processor);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     protected Processor getFailedProcessor(RuntimeException t) {
-        Flow.Processor processor = TappedProcessor.create().onNext(o -> {
+        Flow.Processor processor = MultiTappedProcessor.create().onNext(o -> {
             throw t;
         });
         return HybridProcessor.from(processor);

From da8b1652772304145c71f3d38c77332d669b37a9 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Fri, 27 Dec 2019 21:02:41 +0100
Subject: [PATCH 58/66] Reabase on java.util.concurrent.Flow

Signed-off-by: Daniel Kec 
---
 .../helidon/common/reactive/BaseProcessor.java |  5 +++--
 .../common/reactive/BufferedProcessor.java     |  1 +
 .../common/reactive/ConcatPublisher.java       |  1 +
 .../common/reactive/FailedPublisher.java       |  2 ++
 .../java/io/helidon/common/reactive/Multi.java |  6 +++---
 .../common/reactive/MultiCoupledProcessor.java |  1 +
 .../reactive/MultiDistinctProcessor.java       |  1 +
 .../common/reactive/MultiFlatMapProcessor.java |  3 ++-
 .../common/reactive/MultiFromPublisher.java    |  2 --
 .../common/reactive/MultiLimitProcessor.java   |  1 +
 .../common/reactive/MultiMapProcessor.java     |  1 +
 .../reactive/MultiOnErrorResumeProcessor.java  |  5 +++--
 .../reactive/MultiTakeWhileProcessor.java      |  1 +
 .../common/reactive/MultiTappedProcessor.java  |  3 ++-
 .../helidon/common/reactive/OfPublisher.java   |  1 +
 .../common/reactive/SubscriberReference.java   |  1 +
 .../connector/AdHocConfigBuilder.java          |  4 ++--
 .../connector/AdHocConfigBuilderTest.java      |  9 ++++-----
 .../messaging/connector/ConnectorTest.java     | 18 +++++++++---------
 .../reactive/CancelSubscriber.java             |  2 +-
 .../reactive/CollectSubscriber.java            |  2 +-
 .../reactive/CumulativeProcessor.java          |  6 +++---
 .../microprofile/reactive/ExceptionUtils.java  |  1 +
 .../reactive/FindFirstSubscriber.java          |  2 +-
 .../reactive/FromCompletionStagePublisher.java |  2 +-
 .../microprofile/reactive/GraphBuilder.java    |  2 +-
 .../helidon/microprofile/reactive/MultiRS.java | 16 ++++++++--------
 .../reactive/hybrid/HybridProcessor.java       |  8 ++++----
 .../reactive/hybrid/HybridPublisher.java       |  8 ++++----
 .../reactive/hybrid/HybridSubscriber.java      | 13 ++++---------
 .../reactive/hybrid/HybridSubscription.java    | 15 +++++++--------
 .../reactive/AbstractProcessorTest.java        |  2 +-
 .../microrofile/reactive/EngineTest.java       |  5 +++--
 .../reactive/MultiTappedProcessorTest.java     |  3 ++-
 34 files changed, 81 insertions(+), 72 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 4f97dd259b3..5dc5a88d7ec 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -15,12 +15,13 @@
  */
 package io.helidon.common.reactive;
 
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Processor;
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 import java.util.concurrent.Flow.Subscription;
-import java.util.Objects;
-import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index b6ed6aa5bc0..465342212c2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -19,6 +19,7 @@
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Flow;
 
 /**
  * Processor with back-pressure buffer.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
index ac5d752196f..ed756b1dcbc 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
@@ -19,6 +19,7 @@
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
index 6f35470faf5..9cbefd10085 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
@@ -17,6 +17,8 @@
 
 package io.helidon.common.reactive;
 
+import java.util.concurrent.Flow;
+
 /**
  * Stream from {@link FailedPublisher} sends onError signal after onSubscribe is called.
  *
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index e512f7f050e..5df5366c3b2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -17,15 +17,15 @@
 
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
-
-import io.helidon.common.mapper.Mapper;
-
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import io.helidon.common.mapper.Mapper;
+
 /**
  * Multiple items publisher facility.
  *
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
index 54dc5eddccb..681b312b3b9 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
@@ -19,6 +19,7 @@
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
index 44738c233fe..dfd9de9d12a 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
@@ -18,6 +18,7 @@
 package io.helidon.common.reactive;
 
 import java.util.HashSet;
+import java.util.concurrent.Flow;
 
 /**
  * Filter out all duplicate items.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index b1920f508b2..b5f674c3cc2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -21,6 +21,7 @@
 import java.util.Optional;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
@@ -60,7 +61,7 @@ public static  MultiFlatMapProcessor fromIterableMapper(Function    item type
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
index 09051d5823b..9b6494120d2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
@@ -15,8 +15,6 @@
  */
 package io.helidon.common.reactive;
 
-import org.reactivestreams.Subscription;
-
 import java.util.Objects;
 import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Publisher;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
index 58bab9e9600..c9770a81eda 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
@@ -17,6 +17,7 @@
 
 package io.helidon.common.reactive;
 
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
index 75d31aa294a..3d42045219f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
@@ -16,6 +16,7 @@
 package io.helidon.common.reactive;
 
 import java.util.Objects;
+import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Publisher;
 
 import io.helidon.common.mapper.Mapper;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
index 26f3df21b5d..3a18e3c5a03 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
@@ -19,6 +19,7 @@
 
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 
@@ -51,10 +52,10 @@ public static  MultiOnErrorResumeProcessor resume(Function s
     }
 
     /**
-     * Create new {@link MultiOnErrorResumeProcessor} with supplier for {@link io.helidon.common.reactive.Flow.Publisher}
+     * Create new {@link MultiOnErrorResumeProcessor} with supplier for {@link java.util.concurrent.Flow.Publisher}
      * to resume stream after error is intercepted.
      *
-     * @param supplier or {@link io.helidon.common.reactive.Flow.Publisher}
+     * @param supplier or {@link java.util.concurrent.Flow.Publisher}
      *                 to resume stream after error is intercepted
      * @param       item type
      * @return new {@link MultiOnErrorResumeProcessor}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
index 59734f267ef..d2019148766 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
@@ -17,6 +17,7 @@
 
 package io.helidon.common.reactive;
 
+import java.util.concurrent.Flow;
 import java.util.function.Predicate;
 
 /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
index 1fcd7bb61f3..09d0b28abb1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
@@ -18,6 +18,7 @@
 package io.helidon.common.reactive;
 
 import java.util.Optional;
+import java.util.concurrent.Flow;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -84,7 +85,7 @@ public MultiTappedProcessor onComplete(Runnable runnable) {
      * Set consumer to be executed when onCancel signal is intercepted.
      *
      * @param consumer Consumer to be executed when onCancel signal is intercepted,
-     *                 argument is intercepted {@link io.helidon.common.reactive.Flow.Subscription}.
+     *                 argument is intercepted {@link java.util.concurrent.Flow.Subscription}.
      * @return This {@link MultiTappedProcessor}
      */
     public MultiTappedProcessor onCancel(Consumer consumer) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
index 961cd28c8a5..41d2c7528e3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
@@ -19,6 +19,7 @@
 
 import java.util.Iterator;
 import java.util.Objects;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
index 47f597eaf3a..0054b3f07c0 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
@@ -18,6 +18,7 @@
 package io.helidon.common.reactive;
 
 import java.util.Optional;
+import java.util.concurrent.Flow;
 
 class SubscriberReference implements Flow.Subscriber {
     private Optional> subscriber;
diff --git a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
index c8f476cbd2c..f4e17760227 100644
--- a/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
+++ b/microprofile/messaging/src/main/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilder.java
@@ -17,9 +17,9 @@
 
 package io.helidon.microprofile.messaging.connector;
 
+import java.util.Map;
 import java.util.Properties;
 
-import io.helidon.common.CollectionsHelper;
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 
@@ -44,7 +44,7 @@ AdHocConfigBuilder put(String key, String value) {
     }
 
     AdHocConfigBuilder putAll(Config configToPut) {
-        properties.putAll(configToPut.detach().asMap().orElse(CollectionsHelper.mapOf()));
+        properties.putAll(configToPut.detach().asMap().orElse(Map.of()));
         return this;
     }
 
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
index 07cba2ab298..c5aae551091 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/AdHocConfigBuilderTest.java
@@ -22,7 +22,6 @@
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 
-import static io.helidon.common.CollectionsHelper.mapOf;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.junit.jupiter.api.Test;
@@ -40,7 +39,7 @@ class AdHocConfigBuilderTest {
 
     @Test
     void currentContext() {
-        Map propMap = mapOf(
+        Map propMap = Map.of(
                 "mp.messaging.outcoming.test-channel.key.serializer", AdHocConfigBuilderTest.class.getName()
         );
 
@@ -59,7 +58,7 @@ void currentContext() {
 
     @Test
     void customValueOverride() {
-        Map propMap = mapOf(
+        Map propMap = Map.of(
                 "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG,
                 "mp.messaging.outcoming.test-channel.key.serializer", AdHocConfigBuilderTest.class.getName()
         );
@@ -78,11 +77,11 @@ void customValueOverride() {
 
     @Test
     void putAllTest() {
-        Map propMap = mapOf(
+        Map propMap = Map.of(
                 "mp.messaging.outcoming.test-channel." + TEST_KEY, TEST_TOPIC_CONFIG
         );
 
-        Map propMap2 = mapOf(
+        Map propMap2 = Map.of(
                 "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_1, ADDITION_ATTR_1_VALUE,
                 "mp.messaging.connector." + TEST_CONNECTOR + "." + ADDITION_ATTR_2, ADDITION_ATTR_2_VALUE
         );
diff --git a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
index 02b352ab4be..6fb312846ec 100644
--- a/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
+++ b/microprofile/messaging/src/test/java/io/helidon/microprofile/messaging/connector/ConnectorTest.java
@@ -16,18 +16,18 @@
 
 package io.helidon.microprofile.messaging.connector;
 
-import io.helidon.microprofile.messaging.AbstractCDITest;
-import org.junit.jupiter.api.Test;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import javax.enterprise.inject.spi.DeploymentException;
 
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
+import io.helidon.microprofile.messaging.AbstractCDITest;
 
-import static io.helidon.common.CollectionsHelper.mapOf;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import org.junit.jupiter.api.Test;
+
 public class ConnectorTest extends AbstractCDITest {
 
     @Override
@@ -38,7 +38,7 @@ public void setUp() {
     @Test
     void connectorTest() throws InterruptedException {
         cdiContainer = startCdiContainer(
-                mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                Map.of("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
                 IterableConnector.class,
                 ConnectedBean.class);
         assertTrue(ConnectedBean.LATCH.await(2, TimeUnit.SECONDS));
@@ -47,7 +47,7 @@ void connectorTest() throws InterruptedException {
     @Test
     void connectorWithProcessorTest() throws InterruptedException {
         cdiContainer = startCdiContainer(
-                mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                Map.of("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
                 IterableConnector.class,
                 ConnectedProcessorBean.class);
         assertTrue(ConnectedProcessorBean.LATCH.await(2, TimeUnit.SECONDS));
@@ -55,7 +55,7 @@ void connectorWithProcessorTest() throws InterruptedException {
 
     @Test
     void connectorWithProcessorOnlyTest() throws InterruptedException {
-        Map p = mapOf(
+        Map p = Map.of(
                 "mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector",
                 "mp.messaging.outgoing.iterable-channel-out.connector", "iterable-connector");
         cdiContainer = startCdiContainer(p, IterableConnector.class, ConnectedOnlyProcessorBean.class);
@@ -66,7 +66,7 @@ void connectorWithProcessorOnlyTest() throws InterruptedException {
     void missingConnectorTest() {
         assertThrows(DeploymentException.class, () ->
                 cdiContainer = startCdiContainer(
-                        mapOf("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
+                        Map.of("mp.messaging.incoming.iterable-channel-in.connector", "iterable-connector"),
                         ConnectedBean.class));
     }
 }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
index 89189ea703c..00bb978a93b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CancelSubscriber.java
@@ -22,8 +22,8 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Flow;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
index eeace753437..87c4bad8469 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CollectSubscriber.java
@@ -22,12 +22,12 @@
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.Stage;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
index 3f53edd00e8..3c774eb409b 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/CumulativeProcessor.java
@@ -20,9 +20,9 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Objects;
+import java.util.concurrent.Flow;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
@@ -39,9 +39,9 @@ public class CumulativeProcessor implements Processor {
     private AtomicBoolean chainConnected = new AtomicBoolean(false);
 
     /**
-     * Create {@link org.reactivestreams.Processor} wrapping ordered list of {@link io.helidon.common.reactive.Flow.Processor}s.
+     * Create {@link org.reactivestreams.Processor} wrapping ordered list of {@link java.util.concurrent.Flow.Processor}s.
      *
-     * @param precedingProcessorList ordered list of {@link io.helidon.common.reactive.Flow.Processor}s
+     * @param precedingProcessorList ordered list of {@link java.util.concurrent.Flow.Processor}s
      */
     CumulativeProcessor(List> precedingProcessorList) {
         //preceding processors
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
index 70da09eda72..93a9a4b8628 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/ExceptionUtils.java
@@ -23,6 +23,7 @@ public static void throwUncheckedException(Throwable t) {
         ExceptionUtils.throwWithTypeErasure(t);
     }
 
+    @SuppressWarnings("unchecked")
     private static  void throwWithTypeErasure(Throwable t) throws T {
         throw (T) t;
     }
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
index 862016dd752..fc9e8b62f16 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FindFirstSubscriber.java
@@ -21,8 +21,8 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Flow;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
 
 import org.eclipse.microprofile.reactive.streams.operators.spi.SubscriberWithCompletionStage;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
index 23c99e990ee..7ce1b0bc54d 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/FromCompletionStagePublisher.java
@@ -52,11 +52,11 @@ public void request(long n) {
             @Override
             public void cancel() {
                 cancelled = true;
-                //registerEmitWhenCompleteOnceAction();
             }
         });
     }
 
+    @SuppressWarnings("unchecked")
     private void registerEmitWhenCompleteOnceAction() {
         if (!registered.getAndSet(true)) {
             completionStage.whenComplete((item, throwable) -> {
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 6b47b4f885b..d5fd3cec474 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -22,6 +22,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Flow;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -33,7 +34,6 @@
 import io.helidon.common.reactive.FailedPublisher;
 import io.helidon.common.reactive.MultiFilterProcessor;
 import io.helidon.common.reactive.MultiFlatMapProcessor;
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.MultiLimitProcessor;
 import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.MultiMapProcessor;
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
index 83382efca43..e7513def756 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/MultiRS.java
@@ -17,10 +17,10 @@
 
 package io.helidon.microprofile.reactive;
 
+import java.util.concurrent.Flow;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.Multi;
 import io.helidon.microprofile.reactive.hybrid.HybridPublisher;
 import io.helidon.microprofile.reactive.hybrid.HybridSubscriber;
@@ -35,12 +35,12 @@
 public interface MultiRS {
 
     /**
-     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber}
+     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Subscriber}
      * from {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}.
      *
      * @param subscriber {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
      * @param         type of streamed item
-     * @return {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber}
+     * @return {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Subscriber}
      */
     static  Flow.Subscriber from(Subscriber subscriber) {
         return HybridSubscriber.from(subscriber);
@@ -50,7 +50,7 @@ static  Flow.Subscriber from(Subscriber subscriber) {
      * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
      * from {@link io.helidon.common.reactive Helidon reactive streams} subscriber.
      *
-     * @param subscriber Helidon {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Subscriber}
+     * @param subscriber Helidon {@link io.helidon.common.reactive.Multi} stream {@link java.util.concurrent.Flow.Subscriber}
      * @param         type of streamed item
      * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
      */
@@ -59,12 +59,12 @@ static  Subscriber from(Flow.Subscriber subscriber) {
     }
 
     /**
-     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Publisher}
+     * Create {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Publisher}
      * from {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}.
      *
      * @param publisher {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
      * @param        type of streamed item
-     * @return Multi stream {@link io.helidon.common.reactive.Flow.Publisher}
+     * @return Multi stream {@link java.util.concurrent.Flow.Publisher}
      */
     static  Flow.Publisher from(Publisher publisher) {
         return HybridPublisher.from(publisher);
@@ -72,9 +72,9 @@ static  Flow.Publisher from(Publisher publisher) {
 
     /**
      * Create {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
-     * from {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Publisher}.
+     * from {@link io.helidon.common.reactive.Multi} stream {@link java.util.concurrent.Flow.Publisher}.
      *
-     * @param publisher {@link io.helidon.common.reactive.Multi} stream {@link io.helidon.common.reactive.Flow.Publisher}
+     * @param publisher {@link io.helidon.common.reactive.Multi} stream {@link java.util.concurrent.Flow.Publisher}
      * @param        type of streamed item
      * @return {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
      */
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
index f00609ad8d7..2030156871c 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridProcessor.java
@@ -18,8 +18,8 @@
 package io.helidon.microprofile.reactive.hybrid;
 
 import java.security.InvalidParameterException;
+import java.util.concurrent.Flow;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.Multi;
 
 import org.reactivestreams.Processor;
@@ -28,7 +28,7 @@
 
 /**
  * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Processor}
- * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Processor},
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Processor},
  * to be used interchangeably.
  *
  * @param  type of items processor consumes
@@ -48,9 +48,9 @@ private HybridProcessor(Flow.Processor processor) {
 
     /**
      * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
-     * from {@link io.helidon.common.reactive.Flow.Processor}.
+     * from {@link java.util.concurrent.Flow.Processor}.
      *
-     * @param processor {@link io.helidon.common.reactive.Flow.Processor} to wrap
+     * @param processor {@link java.util.concurrent.Flow.Processor} to wrap
      * @param        type of items processor consumes
      * @param        type of items processor emits
      * @return {@link io.helidon.microprofile.reactive.hybrid.HybridProcessor}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
index 1bf63bbb32b..479602cbd29 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridPublisher.java
@@ -17,14 +17,14 @@
 
 package io.helidon.microprofile.reactive.hybrid;
 
-import io.helidon.common.reactive.Flow;
+import java.util.concurrent.Flow;
 
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
 /**
  * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Publisher}
- * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Publisher},
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Publisher},
  * to be used interchangeably.
  *
  * @param  type of items
@@ -44,9 +44,9 @@ private HybridPublisher(Publisher reactivePublisher) {
 
     /**
      * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
-     * from {@link io.helidon.common.reactive.Flow.Publisher}.
+     * from {@link java.util.concurrent.Flow.Publisher}.
      *
-     * @param publisher {@link io.helidon.common.reactive.Flow.Publisher} to wrap
+     * @param publisher {@link java.util.concurrent.Flow.Publisher} to wrap
      * @param        type of items
      * @return {@link io.helidon.microprofile.reactive.hybrid.HybridPublisher}
      * compatible with {@link org.reactivestreams Reactive Streams}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
index 1e5ee709589..d8fd96bf3c5 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscriber.java
@@ -19,25 +19,20 @@
 
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.logging.Logger;
-
-import io.helidon.common.reactive.Flow;
+import java.util.concurrent.Flow;
 
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 
 /**
  * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscriber}
- * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscriber},
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Subscriber},
  * to be used interchangeably.
  *
  * @param  type of items
  */
 public class HybridSubscriber implements Flow.Subscriber, Subscriber {
 
-    private static final Logger LOGGER = Logger.getLogger(HybridSubscriber.class.getName());
-
     private Optional> flowSubscriber = Optional.empty();
     private Optional> reactiveSubscriber = Optional.empty();
     private Type type;
@@ -54,9 +49,9 @@ private HybridSubscriber(Subscriber subscriber) {
 
     /**
      * Create new {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
-     * from {@link io.helidon.common.reactive.Flow.Subscriber}.
+     * from {@link java.util.concurrent.Flow.Subscriber}.
      *
-     * @param subscriber {@link io.helidon.common.reactive.Flow.Subscriber} to wrap
+     * @param subscriber {@link java.util.concurrent.Flow.Subscriber} to wrap
      * @param         type of items
      * @return {@link io.helidon.microprofile.reactive.hybrid.HybridSubscriber}
      * compatible with {@link org.reactivestreams Reactive Streams}
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
index d4d8bc0d365..0157fd01215 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/hybrid/HybridSubscription.java
@@ -19,14 +19,13 @@
 
 import java.security.InvalidParameterException;
 import java.util.Optional;
-
-import io.helidon.common.reactive.Flow;
+import java.util.concurrent.Flow;
 
 import org.reactivestreams.Subscription;
 
 /**
  * Wrapper for {@link org.reactivestreams Reactive Streams} {@link org.reactivestreams.Subscription}
- * or {@link io.helidon.common.reactive Helidon reactive streams} {@link io.helidon.common.reactive.Flow.Subscription},
+ * or {@link io.helidon.common.reactive Helidon reactive streams} {@link java.util.concurrent.Flow.Subscription},
  * to be used interchangeably.
  */
 public class HybridSubscription implements Flow.Subscription, Subscription {
@@ -45,9 +44,9 @@ private HybridSubscription(Subscription reactiveSubscription) {
 
     /**
      * Create new {@link HybridSubscription}
-     * from {@link io.helidon.common.reactive.Flow.Processor}.
+     * from {@link java.util.concurrent.Flow.Processor}.
      *
-     * @param subscription {@link io.helidon.common.reactive.Flow.Subscription} to wrap
+     * @param subscription {@link java.util.concurrent.Flow.Subscription} to wrap
      * @return {@link HybridSubscription}
      * compatible with {@link org.reactivestreams Reactive Streams}
      * and {@link io.helidon.common.reactive Helidon reactive streams}
@@ -58,9 +57,9 @@ public static HybridSubscription from(Flow.Subscription subscription) {
 
     /**
      * Create new {@link HybridSubscription}
-     * from {@link io.helidon.common.reactive.Flow.Subscription}.
+     * from {@link java.util.concurrent.Flow.Subscription}.
      *
-     * @param subscription {@link io.helidon.common.reactive.Flow.Subscription} to wrap
+     * @param subscription {@link java.util.concurrent.Flow.Subscription} to wrap
      * @return {@link HybridSubscription}
      * compatible with {@link org.reactivestreams Reactive Streams}
      * and {@link io.helidon.common.reactive Helidon reactive streams}
@@ -69,7 +68,7 @@ public static HybridSubscription from(Subscription subscription) {
         return new HybridSubscription(subscription);
     }
 
-    public HybridSubscription onCancel(Runnable runnable){
+    public HybridSubscription onCancel(Runnable runnable) {
         this.onCancel = Optional.of(runnable);
         return this;
     }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
index 2c2839d378b..82764cca1e5 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/AbstractProcessorTest.java
@@ -22,13 +22,13 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Flow;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.stream.LongStream;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 146f3a8e190..0f220cc3867 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -26,6 +26,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Flow;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -39,7 +40,6 @@
 
 import io.helidon.common.reactive.MultiDropWhileProcessor;
 import io.helidon.common.reactive.MultiFilterProcessor;
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.MultiPeekProcessor;
 import io.helidon.common.reactive.MultiSkipProcessor;
 import io.helidon.common.reactive.MultiTakeWhileProcessor;
@@ -390,7 +390,8 @@ void filter() throws InterruptedException, ExecutionException, TimeoutException
     }
 
     @Test
-    @Disabled //TODO: Is this valid scenario?
+    @Disabled
+        //TODO: Is this valid scenario?
     void publisherToSubscriber() throws InterruptedException, ExecutionException, TimeoutException {
         CompletionSubscriber> subscriber = ReactiveStreams.builder()
                 .limit(5L)
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
index d886a849f2e..142118670d0 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/MultiTappedProcessorTest.java
@@ -17,12 +17,13 @@
 
 package io.helidon.microrofile.reactive;
 
-import io.helidon.common.reactive.Flow;
 import io.helidon.common.reactive.MultiTappedProcessor;
 import io.helidon.microprofile.reactive.hybrid.HybridProcessor;
 
 import org.reactivestreams.Processor;
 
+import java.util.concurrent.Flow;
+
 public class MultiTappedProcessorTest extends AbstractProcessorTest {
     @Override
     @SuppressWarnings("unchecked")

From ff2812c6e3d078b9e4df0f6bb7b1be51575c7d50 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sat, 28 Dec 2019 21:39:26 +0100
Subject: [PATCH 59/66] Checkstyle fixes

Signed-off-by: Daniel Kec 
---
 .../reactive/MultiFlatMapProcessor.java       | 15 +++++++++---
 .../common/reactive/MultiMapProcessor.java    |  1 -
 .../helidon/common/reactive/OfPublisher.java  | 23 +++++++++----------
 3 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index b5f674c3cc2..135d35f34be 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -32,6 +32,8 @@
  */
 public class MultiFlatMapProcessor implements Flow.Processor, Multi {
 
+    private static final int DEFAULT_BUFFER_SIZE = 64;
+
     private Function> mapper;
     private SubscriberReference subscriber;
     private Flow.Subscription subscription;
@@ -120,7 +122,11 @@ public void onSubscribe(Flow.Subscription subscription) {
     @Override
     public void onNext(T o) {
         Objects.requireNonNull(o);
-        buffer.offer(o);
+        try {
+            buffer.offer(o);
+        } catch (Throwable t) {
+            onError(t);
+        }
     }
 
     @Override
@@ -141,7 +147,10 @@ public void onComplete() {
     }
 
     private class PublisherBuffer {
-        private BlockingQueue buffer = new ArrayBlockingQueue<>(64);
+
+        private int bufferSize = Integer.parseInt(
+                System.getProperty("helidon.common.reactive.flatMap.buffer.size", String.valueOf(DEFAULT_BUFFER_SIZE)));
+        private BlockingQueue buffer = new ArrayBlockingQueue<>(bufferSize);
         private InnerSubscriber lastSubscriber = null;
 
         public boolean isComplete() {
@@ -162,7 +171,7 @@ public void offer(U o) {
             if (buffer.isEmpty() && (Objects.isNull(lastSubscriber) || lastSubscriber.isDone())) {
                 lastSubscriber = executeMapper(o);
             } else {
-                buffer.offer(o);
+                buffer.add(o);
             }
         }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
index 3d42045219f..49884eae214 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
@@ -51,7 +51,6 @@ protected void hookOnNext(T item) {
         U value = mapper.map(item);
         if (value == null) {
             getSubscription().ifPresent(Flow.Subscription::cancel);
-            //TODO: ask Romain if IllegalStateException is really needed, RS operators TCKs expect NullPointerException
             onError(new NullPointerException("Mapper returned a null value"));
         } else {
             submit(value);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
index 41d2c7528e3..9eef84f2a17 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
@@ -66,23 +66,22 @@ private void trySubmit() {
                     try {
                         while (requestCounter.tryDecrement()) {
                             iterateConcurrentLock.lock();
-                            if (iterator.hasNext() && !cancelled.get()) {
-                                T next = iterator.next();
-                                iterateConcurrentLock.unlock();
-                                Objects.requireNonNull(next);
-                                subscriber.onNext(next);
-                            } else {
-                                if (!completed.getAndSet(true)) {
-                                    subscriber.onComplete();
+                            try {
+                                if (iterator.hasNext() && !cancelled.get()) {
+                                    T next = iterator.next();
+                                    Objects.requireNonNull(next);
+                                    subscriber.onNext(next);
+                                } else {
+                                    if (!completed.getAndSet(true)) {
+                                        subscriber.onComplete();
+                                    }
+                                    break;
                                 }
+                            } finally {
                                 iterateConcurrentLock.unlock();
-                                break;
                             }
                         }
                     } finally {
-                        if (iterateConcurrentLock.isHeldByCurrentThread()) {
-                            iterateConcurrentLock.unlock();
-                        }
                         trampolineLock.set(false);
                     }
                 }

From 66994334b8a32f8e77cfb79aff2fb4443fb0e848 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Sun, 29 Dec 2019 10:09:44 +0100
Subject: [PATCH 60/66] FlatMap buffer overflow fix,   * breaks
 FlatMapStageVerification$InnerSubscriberVerification.required_spec209_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall

Signed-off-by: Daniel Kec 
---
 .../common/reactive/MultiFlatMapProcessor.java  | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index 135d35f34be..7fe38bb4720 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -80,12 +80,11 @@ public static  MultiFlatMapProcessor fromPublisherMapper(Function 0) {
-                innerSubscription.request(requestCount);
-            }
+            innerSubscription.request(Long.MAX_VALUE);
         }
 
         @Override
@@ -217,11 +213,8 @@ public void onSubscribe(Flow.Subscription innerSubscription) {
         public void onNext(R o) {
             Objects.requireNonNull(o);
             MultiFlatMapProcessor.this.subscriber.onNext((T) o);
+            //just counting leftovers
             requestCounter.tryDecrement();
-            long requestCount = requestCounter.get();
-            if (requestCount > 0) {
-                innerSubscription.request(requestCount);
-            }
         }
 
         @Override

From 8c873fa70d8e48a94e522427dcb7c304be005e15 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Mon, 6 Jan 2020 20:56:51 +0100
Subject: [PATCH 61/66] Multi PR review issues fix

Signed-off-by: Daniel Kec 
---
 .../io/helidon/common/reactive/Multi.java     | 89 +++----------------
 .../reactive/MultiFlatMapProcessor.java       |  9 +-
 .../helidon/common/reactive/Subscribable.java | 66 ++++++++++++++
 .../io/helidon/common/reactive/MultiTest.java | 39 ++++----
 .../microprofile/reactive/GraphBuilder.java   |  3 +-
 5 files changed, 105 insertions(+), 101 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 5df5366c3b2..f0bd2eea069 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -84,6 +84,8 @@ default Multi filter(Predicate predicate) {
 
     /**
      * Take the longest prefix of elements from this stream that satisfy the given predicate.
+     * As long as predicate returns true, items from upstream are sent to downstream,
+     * when predicate returns false stream is completed.
      *
      * @param predicate predicate to filter stream with
      * @return Multi
@@ -96,6 +98,8 @@ default Multi takeWhile(Predicate predicate) {
 
     /**
      * Drop the longest prefix of elements from this stream that satisfy the given predicate.
+     * As long as predicate returns true, items from upstream are NOT sent to downstream but being dropped,
+     * predicate is never called again after it returns false for the first time.
      *
      * @param predicate predicate to filter stream with
      * @return Multi
@@ -131,94 +135,25 @@ default Multi skip(long skip) {
     }
 
     /**
-     * Coupled processor sends items received to the passed in subscriber, and emits items received from the passed in publisher.
-     * Cancel, onComplete and onError signals are shared.
-     * 
    -     *     +
-     *     |  Inlet/upstream publisher
-     * +-------+
-     * |   |   |   passed in subscriber
-     * |   +-------------------------->
-     * |       |   passed in publisher
-     * |   +--------------------------+
-     * |   |   |
-     * +-------+
-     *     |  Outlet/downstream subscriber
-     *     v
-     * 
    
+     * Transform item with supplied function and flatten resulting {@link Flow.Publisher} to downstream.
      *
-     * @param                 Outlet and passed in publisher item type
-     * @param passedInSubscriber gets all items from upstream/inlet
-     * @param passedInPublisher  emits to downstream/outlet
+     * @param publisherMapper {@link Function} receiving item as parameter and returning {@link Flow.Publisher}
      * @return Multi
      */
-    default  Multi coupled(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
-        MultiCoupledProcessor processor = new MultiCoupledProcessor<>(passedInSubscriber, passedInPublisher);
+    default Multi flatMap(Function> publisherMapper) {
+        MultiFlatMapProcessor processor = MultiFlatMapProcessor.fromPublisherMapper(publisherMapper);
         this.subscribe(processor);
         return processor;
     }
 
     /**
-     * Executes given {@link java.lang.Runnable} when any of signals onComplete, onCancel or onError is received.
+     * Transform item with supplied function and flatten resulting {@link Iterable} to downstream.
      *
-     * @param onTerminate {@link java.lang.Runnable} to be executed.
+     * @param iterableMapper {@link Function} receiving item as parameter and returning {@link Iterable}
      * @return Multi
      */
-    default Multi onTerminate(Runnable onTerminate) {
-        MultiTappedProcessor processor = MultiTappedProcessor.create()
-                .onComplete(onTerminate)
-                .onCancel((s) -> onTerminate.run())
-                .onError((t) -> onTerminate.run());
-        this.subscribe(processor);
-        return processor;
-    }
-
-    /**
-     * Executes given {@link java.lang.Runnable} when onComplete signal is received.
-     *
-     * @param onTerminate {@link java.lang.Runnable} to be executed.
-     * @return Multi
-     */
-    default Multi onComplete(Runnable onTerminate) {
-        MultiTappedProcessor processor = MultiTappedProcessor.create()
-                .onComplete(onTerminate);
-        this.subscribe(processor);
-        return processor;
-    }
-
-    /**
-     * Executes given {@link java.lang.Runnable} when onError signal is received.
-     *
-     * @param onErrorConsumer {@link java.lang.Runnable} to be executed.
-     * @return Multi
-     */
-    default Multi onError(Consumer onErrorConsumer) {
-        MultiTappedProcessor processor = MultiTappedProcessor.create()
-                .onError(onErrorConsumer);
-        this.subscribe(processor);
-        return processor;
-    }
-
-    /**
-     * {@link java.util.function.Function} providing one item to be submitted as onNext in case of onError signal is received.
-     *
-     * @param onError Function receiving {@link java.lang.Throwable} as argument and producing one item to resume stream with.
-     * @return Multi
-     */
-    default Multi onErrorResume(Function onError) {
-        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resume(onError);
-        this.subscribe(processor);
-        return processor;
-    }
-
-    /**
-     * Resume stream from supplied publisher if onError signal is intercepted.
-     *
-     * @param onError supplier of new stream publisher
-     * @return Multi
-     */
-    default Multi onErrorResumeWith(Function> onError) {
-        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resumeWith(onError);
+    default Multi flatMapIterable(Function> iterableMapper) {
+        MultiFlatMapProcessor processor = MultiFlatMapProcessor.fromIterableMapper(iterableMapper);
         this.subscribe(processor);
         return processor;
     }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index 7fe38bb4720..6532b82a0bd 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -55,10 +55,9 @@ private MultiFlatMapProcessor() {
      * @return {@link MultiFlatMapProcessor}
      */
     @SuppressWarnings("unchecked")
-    public static  MultiFlatMapProcessor fromIterableMapper(Function> mapper) {
-        Function> iterableMapper = (Function>) mapper;
+    public static  MultiFlatMapProcessor fromIterableMapper(Function> mapper) {
         MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor<>();
-        flatMapProcessor.mapper = o -> (Multi) Multi.from(iterableMapper.apply(o));
+        flatMapProcessor.mapper = o -> (Multi) Multi.from(mapper.apply(o));
         return flatMapProcessor;
     }
 
@@ -70,8 +69,8 @@ public static  MultiFlatMapProcessor fromIterableMapper(Function MultiFlatMapProcessor fromPublisherMapper(Function> mapper) {
-        Function> publisherMapper = (Function>) mapper;
+    public static  MultiFlatMapProcessor fromPublisherMapper(Function> mapper) {
+        Function> publisherMapper = (Function>) mapper;
         MultiFlatMapProcessor flatMapProcessor = new MultiFlatMapProcessor();
         flatMapProcessor.mapper = t -> (Flow.Publisher) publisherMapper.apply(t);
         return flatMapProcessor;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java b/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
index d0c0d049959..0ff97a559b3 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
@@ -18,6 +18,7 @@
 import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Publisher;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 /**
  * Decorated publisher that allows subscribing to individual events with java functions.
@@ -68,4 +69,69 @@ default void subscribe(Consumer consumer, Consumer
 
         this.subscribe(new FunctionalSubscriber<>(consumer, errorConsumer, completeConsumer, subscriptionConsumer));
     }
+
+    /**
+     * Executes given {@link java.lang.Runnable} when any of signals onComplete, onCancel or onError is received.
+     *
+     * @param onTerminate {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onTerminate(Runnable onTerminate) {
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
+                .onComplete(onTerminate)
+                .onCancel((s) -> onTerminate.run())
+                .onError((t) -> onTerminate.run());
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Executes given {@link java.lang.Runnable} when onComplete signal is received.
+     *
+     * @param onTerminate {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onComplete(Runnable onTerminate) {
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
+                .onComplete(onTerminate);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Executes given {@link java.lang.Runnable} when onError signal is received.
+     *
+     * @param onErrorConsumer {@link java.lang.Runnable} to be executed.
+     * @return Multi
+     */
+    default Multi onError(Consumer onErrorConsumer) {
+        MultiTappedProcessor processor = MultiTappedProcessor.create()
+                .onError(onErrorConsumer);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * {@link java.util.function.Function} providing one item to be submitted as onNext in case of onError signal is received.
+     *
+     * @param onError Function receiving {@link java.lang.Throwable} as argument and producing one item to resume stream with.
+     * @return Multi
+     */
+    default Multi onErrorResume(Function onError) {
+        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resume(onError);
+        this.subscribe(processor);
+        return processor;
+    }
+
+    /**
+     * Resume stream from supplied publisher if onError signal is intercepted.
+     *
+     * @param onError supplier of new stream publisher
+     * @return Multi
+     */
+    default Multi onErrorResumeWith(Function> onError) {
+        MultiOnErrorResumeProcessor processor = MultiOnErrorResumeProcessor.resumeWith(onError);
+        this.subscribe(processor);
+        return processor;
+    }
 }
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index 8f74f81eb3b..efcea98ff0a 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -16,13 +16,11 @@
 package io.helidon.common.reactive;
 
 import java.util.Arrays;
-import java.util.List;
 import java.util.Collections;
-import java.util.concurrent.Flow.Subscription;
-
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Flow.Subscription;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -31,8 +29,6 @@
 
 import io.helidon.common.mapper.Mapper;
 
-import org.junit.jupiter.api.Test;
-
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.CoreMatchers.instanceOf;
@@ -42,6 +38,8 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.empty;
 
+import org.junit.jupiter.api.Test;
+
 /**
  * {@link MultiTest} test.
  */
@@ -246,7 +244,6 @@ public void testMapBadMapperNullValue() {
         MultiTestSubscriber subscriber = new MultiTestSubscriber<>();
         Multi.just("foo", "bar").map((Mapper) item -> null).subscribe(subscriber);
         assertThat(subscriber.isComplete(), is(equalTo(false)));
-        //TODO: ask Romain if IllegalStateException is really needed, RS operators TCKs expect NullPointerException
         assertThat(subscriber.getLastError(), is(instanceOf(NullPointerException.class)));
         assertThat(subscriber.getItems(), is(empty()));
     }
@@ -364,19 +361,25 @@ void testOnErrorResumeWith() throws ExecutionException, InterruptedException, Ti
     }
 
     @Test
-    void testCoupled() throws ExecutionException, InterruptedException, TimeoutException {
-        final List TEST_DATA = List.of(1, 2, 3, 4, 3, 2, 1, 0);
-
-        CountDownLatch countDownLatch = new CountDownLatch(TEST_DATA.size());
-        MultiPeekProcessor multiPeekProcessor = new MultiPeekProcessor<>(i -> countDownLatch.countDown());
-
-        List result = Multi.just(TEST_DATA)
-                .coupled(multiPeekProcessor, multiPeekProcessor)
+    void testFlatMap() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList("abc", "xyz");
+        final List EXPECTED = Arrays.asList("a", "b", "c", "x", "y", "z");
+        List result = Multi.just(TEST_DATA)
+                .flatMap(s -> Multi.just(s.chars().mapToObj(Character::toString).collect(Collectors.toList())))
                 .collectList()
-                .get(1, TimeUnit.SECONDS);
+                .get();
+        assertThat(result, is(equalTo(EXPECTED)));
+    }
 
-        countDownLatch.await(1, TimeUnit.SECONDS);
-        assertThat(result, is(equalTo(TEST_DATA)));
+    @Test
+    void testFlatMapIterable() throws ExecutionException, InterruptedException {
+        final List TEST_DATA = Arrays.asList("abc", "xyz");
+        final List EXPECTED = Arrays.asList("a", "b", "c", "x", "y", "z");
+        List result = Multi.just(TEST_DATA)
+                .flatMapIterable(s -> s.chars().mapToObj(Character::toString).collect(Collectors.toList()))
+                .collectList()
+                .get();
+        assertThat(result, is(equalTo(EXPECTED)));
     }
 
     @Test
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index d5fd3cec474..24e6d8f3b11 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -123,7 +123,8 @@ private GraphBuilder() {
             addProcessor(MultiFlatMapProcessor.fromPublisherMapper(pubMapper));
         });
         registerStage(Stage.FlatMapIterable.class, stage -> {
-            addProcessor(MultiFlatMapProcessor.fromIterableMapper(stage.getMapper()));
+            Function> mapper = (Function>) stage.getMapper();
+            addProcessor(MultiFlatMapProcessor.fromIterableMapper(o -> (Iterable) mapper.apply(o)));
         });
         registerStage(Stage.FlatMapCompletionStage.class, stage -> {
             addProcessor(new FlatMapCompletionStageProcessor(stage.getMapper()));

From e17290c2741faa95c45fb7e646e8d052c87a57bd Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 7 Jan 2020 14:30:42 +0100
Subject: [PATCH 62/66] Multi PR review issues fix

Signed-off-by: Daniel Kec 
---
 .../common/reactive/ConcatPublisher.java      |   2 +-
 .../common/reactive/FailedPublisher.java      |  55 --------
 .../common/reactive/FixedItemsPublisher.java  | 119 ------------------
 ...fPublisher.java => IterablePublisher.java} |  17 ++-
 .../io/helidon/common/reactive/Multi.java     |  30 ++---
 .../reactive/MultiCoupledProcessor.java       |  15 ++-
 .../reactive/MultiDistinctProcessor.java      |  13 +-
 .../reactive/MultiDropWhileProcessor.java     |  10 +-
 .../helidon/common/reactive/MultiError.java   |  19 ++-
 .../common/reactive/MultiFilterProcessor.java |  10 +-
 .../common/reactive/MultiFirstProcessor.java  |  19 +++
 .../reactive/MultiFlatMapProcessor.java       |   3 +-
 .../common/reactive/MultiLimitProcessor.java  |  10 +-
 .../common/reactive/MultiMapProcessor.java    |  12 +-
 .../common/reactive/MultiPeekProcessor.java   |  10 +-
 .../common/reactive/MultiSkipProcessor.java   |  10 +-
 .../reactive/MultiTakeWhileProcessor.java     |  10 +-
 .../microprofile/reactive/GraphBuilder.java   |  29 +++--
 .../microrofile/reactive/EngineTest.java      |  10 +-
 19 files changed, 162 insertions(+), 241 deletions(-)
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/FixedItemsPublisher.java
 rename common/reactive/src/main/java/io/helidon/common/reactive/{OfPublisher.java => IterablePublisher.java} (86%)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
index ed756b1dcbc..52fa18053b9 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
@@ -27,7 +27,7 @@
  *
  * @param  item type
  */
-public class ConcatPublisher implements Flow.Publisher, Multi {
+public class ConcatPublisher implements Multi {
     private FirstProcessor firstProcessor;
     private SecondProcessor secondProcessor;
     private Flow.Subscriber subscriber;
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
deleted file mode 100644
index 9cbefd10085..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FailedPublisher.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive;
-
-import java.util.concurrent.Flow;
-
-/**
- * Stream from {@link FailedPublisher} sends onError signal after onSubscribe is called.
- *
- * @param  item type
- */
-public class FailedPublisher implements Flow.Publisher, Multi {
-
-    private Throwable throwable;
-
-    /**
-     * Create new {@link FailedPublisher}.
-     *
-     * @param throwable to fail stream with
-     */
-    public FailedPublisher(Throwable throwable) {
-        this.throwable = throwable;
-    }
-
-    @Override
-    public void subscribe(Flow.Subscriber subscriber) {
-        subscriber.onSubscribe(new Flow.Subscription() {
-            @Override
-            public void request(long n) {
-                subscriber.onError(throwable);
-            }
-
-            @Override
-            public void cancel() {
-
-            }
-        });
-        subscriber.onError(throwable);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/FixedItemsPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/FixedItemsPublisher.java
deleted file mode 100644
index 036d3af7e55..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/FixedItemsPublisher.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive;
-
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.Queue;
-import java.util.concurrent.Flow;
-import java.util.concurrent.Flow.Publisher;
-import java.util.concurrent.Flow.Subscriber;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Fixed items publisher implementation.
- */
-final class FixedItemsPublisher implements Publisher {
-
-    private final Queue queue;
-    private final SingleSubscriberHolder subscriber;
-    private final RequestedCounter requested;
-    private final AtomicBoolean publishing;
-
-    FixedItemsPublisher(Collection items) {
-        queue = new LinkedList<>(items);
-        subscriber = new SingleSubscriberHolder<>();
-        requested = new RequestedCounter();
-        publishing = new AtomicBoolean(false);
-    }
-
-    @Override
-    public void subscribe(Flow.Subscriber s) {
-        if (subscriber.register(s)) {
-
-            // prevent onNext from inside of onSubscribe
-            publishing.set(true);
-
-            try {
-                s.onSubscribe(new Flow.Subscription() {
-                    @Override
-                    public void request(long n) {
-                        requested.increment(n, t -> tryComplete(t));
-                        tryPublish();
-                    }
-
-                    @Override
-                    public void cancel() {
-                        subscriber.cancel();
-                    }
-                });
-            } finally {
-                publishing.set(false);
-            }
-
-            // give onNext a chance in case request has been invoked in
-            // onSubscribe
-            tryPublish();
-        }
-    }
-
-    private void tryPublish() {
-        boolean immediateRetry = true;
-        while (immediateRetry) {
-            immediateRetry = false;
-
-            // Publish, if can
-            if (!subscriber.isClosed()
-                    && requested.get() > 0
-                    && publishing.compareAndSet(false, true)) {
-
-                try {
-
-                    Flow.Subscriber sub = this.subscriber.get();
-                    while (!subscriber.isClosed()
-                            && requested.tryDecrement()
-                            && !queue.isEmpty()) {
-
-                        T item = queue.poll();
-                        if (item != null) {
-                            sub.onNext(item);
-                        }
-                    }
-                    if (queue.isEmpty()) {
-                        tryComplete();
-                    }
-
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    tryComplete(e);
-                } catch (Exception e) {
-                    tryComplete(e);
-                } finally {
-                    // give a chance to some other thread to publish
-                    publishing.set(false);
-                }
-            }
-        }
-    }
-
-    private void tryComplete() {
-        subscriber.close(Subscriber::onComplete);
-    }
-
-    private void tryComplete(Throwable t) {
-        subscriber.close(sub -> sub.onError(t));
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/IterablePublisher.java
similarity index 86%
rename from common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
rename to common/reactive/src/main/java/io/helidon/common/reactive/IterablePublisher.java
index 9eef84f2a17..b582422b6f9 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/OfPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/IterablePublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@
  *
  * @param  item type
  */
-public class OfPublisher implements Flow.Publisher {
+class IterablePublisher implements Flow.Publisher {
     private Iterable iterable;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
     private AtomicBoolean completed = new AtomicBoolean(false);
@@ -36,13 +36,20 @@ public class OfPublisher implements Flow.Publisher {
     private final RequestedCounter requestCounter = new RequestedCounter();
     private final ReentrantLock iterateConcurrentLock = new ReentrantLock();
 
+    private IterablePublisher() {
+    }
+
     /**
-     * Create new {@link OfPublisher}.
+     * Create new {@link IterablePublisher}.
      *
      * @param iterable to create publisher from
+     * @param       Item type
+     * @return new instance of {@link IterablePublisher}
      */
-    public OfPublisher(Iterable iterable) {
-        this.iterable = iterable;
+    static  IterablePublisher create(Iterable iterable) {
+        IterablePublisher instance = new IterablePublisher<>();
+        instance.iterable = iterable;
+        return instance;
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index f0bd2eea069..526345a8bf1 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -42,7 +42,7 @@ public interface Multi extends Subscribable {
      * @throws NullPointerException if mapper is {@code null}
      */
     default  Multi map(Mapper mapper) {
-        MultiMapProcessor processor = new MultiMapProcessor<>(mapper);
+        MultiMapProcessor processor = MultiMapProcessor.create(mapper);
         this.subscribe(processor);
         return processor;
     }
@@ -54,7 +54,7 @@ default  Multi map(Mapper mapper) {
      * @return Multi
      */
     default Multi peek(Consumer consumer) {
-        MultiPeekProcessor processor = new MultiPeekProcessor(consumer);
+        MultiPeekProcessor processor = MultiPeekProcessor.create(consumer);
         this.subscribe(processor);
         return processor;
     }
@@ -65,7 +65,7 @@ default Multi peek(Consumer consumer) {
      * @return Multi
      */
     default Multi distinct() {
-        MultiDistinctProcessor processor = new MultiDistinctProcessor<>();
+        MultiDistinctProcessor processor = MultiDistinctProcessor.create();
         this.subscribe(processor);
         return processor;
     }
@@ -77,7 +77,7 @@ default Multi distinct() {
      * @return Multi
      */
     default Multi filter(Predicate predicate) {
-        MultiFilterProcessor processor = new MultiFilterProcessor<>(predicate);
+        MultiFilterProcessor processor = MultiFilterProcessor.create(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -91,7 +91,7 @@ default Multi filter(Predicate predicate) {
      * @return Multi
      */
     default Multi takeWhile(Predicate predicate) {
-        MultiTakeWhileProcessor processor = new MultiTakeWhileProcessor<>(predicate);
+        MultiTakeWhileProcessor processor = MultiTakeWhileProcessor.create(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -105,7 +105,7 @@ default Multi takeWhile(Predicate predicate) {
      * @return Multi
      */
     default Multi dropWhile(Predicate predicate) {
-        MultiDropWhileProcessor processor = new MultiDropWhileProcessor<>(predicate);
+        MultiDropWhileProcessor processor = MultiDropWhileProcessor.create(predicate);
         this.subscribe(processor);
         return processor;
     }
@@ -117,7 +117,7 @@ default Multi dropWhile(Predicate predicate) {
      * @return Multi
      */
     default Multi limit(long limit) {
-        MultiLimitProcessor processor = new MultiLimitProcessor<>(limit);
+        MultiLimitProcessor processor = MultiLimitProcessor.create(limit);
         this.subscribe(processor);
         return processor;
     }
@@ -129,7 +129,7 @@ default Multi limit(long limit) {
      * @return Multi
      */
     default Multi skip(long skip) {
-        MultiSkipProcessor processor = new MultiSkipProcessor<>(skip);
+        MultiSkipProcessor processor = MultiSkipProcessor.create(skip);
         this.subscribe(processor);
         return processor;
     }
@@ -197,7 +197,7 @@ default  Single collect(Collector collector) {
      * @return Single
      */
     default Single first() {
-        MultiFirstProcessor processor = new MultiFirstProcessor<>();
+        MultiFirstProcessor processor = MultiFirstProcessor.create();
         this.subscribe(processor);
         return processor;
     }
@@ -227,7 +227,7 @@ static  Multi from(Publisher source) {
      * @throws NullPointerException if iterable is {@code null}
      */
     static  Multi from(Iterable iterable) {
-        return Multi.from(new OfPublisher(iterable));
+        return Multi.from(IterablePublisher.create(iterable));
     }
 
 
@@ -240,7 +240,7 @@ static  Multi from(Iterable iterable) {
      * @throws NullPointerException if items is {@code null}
      */
     static  Multi just(Collection items) {
-        return new MultiFromPublisher<>(new FixedItemsPublisher<>(items));
+        return Multi.from(items);
     }
 
     /**
@@ -253,7 +253,7 @@ static  Multi just(Collection items) {
      */
     @SafeVarargs
     static  Multi just(T... items) {
-        return new MultiFromPublisher<>(new FixedItemsPublisher<>(List.of(items)));
+        return Multi.from(List.of(items));
     }
 
     /**
@@ -266,7 +266,7 @@ static  Multi just(T... items) {
      * @throws NullPointerException if error is {@code null}
      */
     static  Multi error(Throwable error) {
-        return new FailedPublisher(error);
+        return MultiError.create(error);
     }
 
     /**
@@ -276,7 +276,7 @@ static  Multi error(Throwable error) {
      * @return Multi
      */
     static  Multi empty() {
-        return MultiEmpty.instance();
+        return MultiEmpty.instance();
     }
 
     /**
@@ -286,7 +286,7 @@ static  Multi empty() {
      * @return Multi
      */
     static  Multi never() {
-        return MultiNever.instance();
+        return MultiNever.instance();
     }
 
     /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
index 681b312b3b9..e182038f894 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
@@ -51,17 +51,24 @@ public class MultiCoupledProcessor implements Flow.Processor, Multi<
     private Flow.Subscription passedInPublisherSubscription;
     private AtomicBoolean cancelled = new AtomicBoolean(false);
 
+    private MultiCoupledProcessor(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
+        this.passedInSubscriber = SubscriberReference.create(passedInSubscriber);
+        this.passedInPublisher = passedInPublisher;
+        this.inletSubscriber = this;
+    }
 
     /**
      * Create new {@link MultiCoupledProcessor}.
      *
      * @param passedInSubscriber to send items from inlet to
      * @param passedInPublisher  to get items for outlet from
+     * @param                 Inlet and passed in subscriber item type
+     * @param                 Outlet and passed in publisher item type
+     * @return {@link MultiCoupledProcessor}
      */
-    public MultiCoupledProcessor(Flow.Subscriber passedInSubscriber, Flow.Publisher passedInPublisher) {
-        this.passedInSubscriber = SubscriberReference.create(passedInSubscriber);
-        this.passedInPublisher = passedInPublisher;
-        this.inletSubscriber = this;
+    public static  MultiCoupledProcessor create(Flow.Subscriber passedInSubscriber,
+                                                            Flow.Publisher passedInPublisher) {
+        return new MultiCoupledProcessor<>(passedInSubscriber, passedInPublisher);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
index dfd9de9d12a..5b1a231f6bd 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
@@ -26,13 +26,20 @@
  * @param  item type
  */
 public class MultiDistinctProcessor extends BufferedProcessor implements Multi {
-    private final HashSet distinctSet;
+
+    private final HashSet distinctSet = new HashSet();
+
+    private MultiDistinctProcessor() {
+    }
 
     /**
      * Create new {@link MultiDistinctProcessor}.
+     *
+     * @param  item type
+     * @return {@link MultiDistinctProcessor}
      */
-    public MultiDistinctProcessor() {
-        this.distinctSet = new HashSet();
+    public static  MultiDistinctProcessor create() {
+        return new MultiDistinctProcessor<>();
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
index 88bd10e5ee8..ffb5550dc93 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
@@ -29,13 +29,19 @@ public class MultiDropWhileProcessor extends BufferedProcessor implemen
 
     private boolean foundNotMatching = false;
 
+    private MultiDropWhileProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
     /**
      * Drop the longest prefix of elements from this stream that satisfy the given predicate.
      *
+     * @param        Item type
      * @param predicate provided predicate to filter stream with
+     * @return {@link MultiDropWhileProcessor}
      */
-    public MultiDropWhileProcessor(Predicate predicate) {
-        this.predicate = predicate;
+    public static  MultiDropWhileProcessor create(Predicate predicate) {
+        return new MultiDropWhileProcessor<>(predicate);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
index b9b8427776c..76130466f67 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
@@ -16,6 +16,7 @@
 package io.helidon.common.reactive;
 
 import java.util.Objects;
+import java.util.concurrent.Flow;
 import java.util.concurrent.Flow.Publisher;
 import java.util.concurrent.Flow.Subscriber;
 
@@ -29,13 +30,27 @@ final class MultiError implements Multi {
 
     private final Throwable error;
 
-    MultiError(Throwable error) {
+    private MultiError(Throwable error) {
         this.error = Objects.requireNonNull(error, "error");
     }
 
+    static  MultiError create(Throwable error) {
+        return new MultiError(error);
+    }
+
     @Override
     public void subscribe(Subscriber subscriber) {
-        subscriber.onSubscribe(EmptySubscription.INSTANCE);
+        subscriber.onSubscribe(new Flow.Subscription() {
+            @Override
+            public void request(long n) {
+                subscriber.onError(error);
+            }
+
+            @Override
+            public void cancel() {
+
+            }
+        });
         subscriber.onError(error);
     }
 }
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
index 7f55c3e3fab..17cfdd2eaab 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
@@ -28,13 +28,19 @@ public class MultiFilterProcessor extends BufferedProcessor implements
 
     private Predicate predicate;
 
+    private MultiFilterProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
     /**
      * Processor filtering stream with supplied predicate.
      *
      * @param predicate provided predicate to filter stream with
+     * @param        both input/output type
+     * @return {@link MultiFilterProcessor}
      */
-    public MultiFilterProcessor(Predicate predicate) {
-        this.predicate = predicate;
+    public static  MultiFilterProcessor create(Predicate predicate) {
+        return new MultiFilterProcessor<>(predicate);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
index ae2a6185b5d..7c82b036f5e 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
@@ -15,12 +15,31 @@
  */
 package io.helidon.common.reactive;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 /**
  * Processor of {@code Multi} to {@code Single}.
+ *
  * @param  item type
  */
 final class MultiFirstProcessor extends BaseProcessor implements Single {
 
+    private AtomicBoolean nextCalled = new AtomicBoolean(false);
+
+    private MultiFirstProcessor() {
+    }
+
+    static  MultiFirstProcessor create() {
+        return new MultiFirstProcessor<>();
+    }
+
+    @Override
+    public void onNext(T item) {
+        if (!nextCalled.getAndSet(true)) {
+            super.onNext(item);
+        }
+    }
+
     @Override
     protected void hookOnNext(T item) {
         submit(item);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index 6532b82a0bd..d866e0372eb 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -40,11 +40,10 @@ public class MultiFlatMapProcessor implements Flow.Processor, Multi
     private RequestedCounter requestCounter = new RequestedCounter();
     private Flow.Subscription innerSubscription;
     private AtomicBoolean onCompleteReceivedAlready = new AtomicBoolean(false);
-    private PublisherBuffer buffer;
+    private PublisherBuffer buffer = new PublisherBuffer<>();
     private Optional error = Optional.empty();
 
     private MultiFlatMapProcessor() {
-        buffer = new PublisherBuffer<>();
     }
 
     /**
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
index c9770a81eda..382ec045864 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
@@ -29,13 +29,19 @@ public class MultiLimitProcessor extends BufferedProcessor implements M
 
     private final AtomicLong counter;
 
+    private MultiLimitProcessor(Long limit) {
+        counter = new AtomicLong(limit);
+    }
+
     /**
      * Processor with specified number of allowed items.
      *
      * @param limit number of items to pass
+     * @param    both input/output type
+     * @return {@link MultiLimitProcessor}
      */
-    public MultiLimitProcessor(Long limit) {
-        counter = new AtomicLong(limit);
+    public static  MultiLimitProcessor create(Long limit) {
+        return new MultiLimitProcessor<>(limit);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
index 49884eae214..3927c1f79ed 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
@@ -31,16 +31,22 @@ public final class MultiMapProcessor extends BufferedProcessor imple
 
     private final Mapper mapper;
 
+    private MultiMapProcessor(Mapper mapper) {
+        this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
+    }
+
     /**
      * Processor of {@link Publisher} to {@link Single} that publishes and maps each received item.
      *
      * @param mapper supplied for all items to be mapped with
+     * @param     subscribed type
+     * @param     published type
+     * @return {@link MultiMapProcessor}
      */
-    public MultiMapProcessor(Mapper mapper) {
-        this.mapper = Objects.requireNonNull(mapper, "mapper is null!");
+    public static  MultiMapProcessor create(Mapper mapper) {
+        return new MultiMapProcessor(mapper);
     }
 
-
     @Override
     protected void hookOnCancel(Flow.Subscription subscription) {
         subscription.cancel();
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
index ed5c36e8ff6..3f0eee0bdd6 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
@@ -28,13 +28,19 @@ public class MultiPeekProcessor extends BufferedProcessor implements Mu
 
     private Consumer consumer;
 
+    private MultiPeekProcessor(Consumer consumer) {
+        this.consumer = consumer;
+    }
+
     /**
      * Invoke supplied consumer for every item in the stream.
      *
      * @param consumer supplied consumer to be invoke for every item
+     * @param       both input/output type
+     * @return {@link MultiPeekProcessor}
      */
-    public MultiPeekProcessor(Consumer consumer) {
-        this.consumer = consumer;
+    public static  MultiPeekProcessor create(Consumer consumer) {
+        return new MultiPeekProcessor<>(consumer);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
index 6ee3fc6b2df..982373348f6 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
@@ -28,13 +28,19 @@ public class MultiSkipProcessor extends BufferedProcessor implements Mu
 
     private final AtomicLong counter;
 
+    private MultiSkipProcessor(Long skip) {
+        counter = new AtomicLong(skip);
+    }
+
     /**
      * Create new {@link MultiSkipProcessor}.
      *
      * @param skip number of items to be skipped
+     * @param   item type
+     * @return {@link MultiSkipProcessor}
      */
-    public MultiSkipProcessor(Long skip) {
-        counter = new AtomicLong(skip);
+    public static  MultiSkipProcessor create(Long skip) {
+        return new MultiSkipProcessor(skip);
     }
 
     @Override
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
index d2019148766..63eb311e32f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
@@ -28,13 +28,19 @@
 public class MultiTakeWhileProcessor extends BufferedProcessor implements Multi {
     private Predicate predicate;
 
+    private MultiTakeWhileProcessor(Predicate predicate) {
+        this.predicate = predicate;
+    }
+
     /**
      * Create new {@link MultiTakeWhileProcessor}.
      *
      * @param predicate provided predicate to filter stream with
+     * @param         Item type
+     * @return {@link MultiTakeWhileProcessor}
      */
-    public MultiTakeWhileProcessor(Predicate predicate) {
-        this.predicate = predicate;
+    public static  MultiTakeWhileProcessor create(Predicate predicate) {
+        return new MultiTakeWhileProcessor<>(predicate);
     }
 
     @Override
diff --git a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
index 24e6d8f3b11..7795865b589 100644
--- a/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
+++ b/microprofile/reactive-streams/src/main/java/io/helidon/microprofile/reactive/GraphBuilder.java
@@ -28,16 +28,14 @@
 
 import io.helidon.common.reactive.BufferedProcessor;
 import io.helidon.common.reactive.ConcatPublisher;
+import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.MultiCoupledProcessor;
 import io.helidon.common.reactive.MultiDistinctProcessor;
 import io.helidon.common.reactive.MultiDropWhileProcessor;
-import io.helidon.common.reactive.FailedPublisher;
 import io.helidon.common.reactive.MultiFilterProcessor;
 import io.helidon.common.reactive.MultiFlatMapProcessor;
 import io.helidon.common.reactive.MultiLimitProcessor;
-import io.helidon.common.reactive.Multi;
 import io.helidon.common.reactive.MultiMapProcessor;
-import io.helidon.common.reactive.OfPublisher;
 import io.helidon.common.reactive.MultiOnErrorResumeProcessor;
 import io.helidon.common.reactive.MultiPeekProcessor;
 import io.helidon.common.reactive.MultiSkipProcessor;
@@ -75,10 +73,10 @@ private GraphBuilder() {
             multi = new ConcatPublisher<>(firstPublisher, secondPublisher);
         });
         registerStage(Stage.Of.class, stage -> {
-            multi = Multi.from(new OfPublisher(stage.getElements()));
+            multi = Multi.from((Iterable) stage.getElements());
         });
         registerStage(Stage.Failed.class, stage -> {
-            multi = Multi.from(new FailedPublisher<>(stage.getError()));
+            multi = Multi.error(stage.getError());
         });
         registerStage(Stage.FromCompletionStage.class, stage -> {
             multi = MultiRS.toMulti(new FromCompletionStagePublisher<>(stage.getCompletionStage(), false));
@@ -88,32 +86,32 @@ private GraphBuilder() {
         });
         registerStage(Stage.Map.class, stage -> {
             Function mapper = (Function) stage.getMapper();
-            addProcessor(new MultiMapProcessor<>(mapper::apply));
+            addProcessor(MultiMapProcessor.create(mapper::apply));
         });
         registerStage(Stage.Filter.class, stage -> {
-            addProcessor(new MultiFilterProcessor<>(stage.getPredicate()));
+            addProcessor(MultiFilterProcessor.create(stage.getPredicate()));
         });
         registerStage(Stage.TakeWhile.class, stage -> {
-            addProcessor(new MultiTakeWhileProcessor<>(stage.getPredicate()));
+            addProcessor(MultiTakeWhileProcessor.create(stage.getPredicate()));
         });
         registerStage(Stage.DropWhile.class, stage -> {
-            addProcessor(new MultiDropWhileProcessor<>(stage.getPredicate()));
+            addProcessor(MultiDropWhileProcessor.create(stage.getPredicate()));
         });
         registerStage(Stage.Peek.class, stage -> {
             Consumer peekConsumer = (Consumer) stage.getConsumer();
-            addProcessor(new MultiPeekProcessor<>(peekConsumer));
+            addProcessor(MultiPeekProcessor.create(peekConsumer));
         });
         registerStage(Stage.ProcessorStage.class, stage -> {
             addProcessor(stage.getRsProcessor());
         });
         registerStage(Stage.Limit.class, stage -> {
-            addProcessor(new MultiLimitProcessor<>(stage.getLimit()));
+            addProcessor(MultiLimitProcessor.create(stage.getLimit()));
         });
         registerStage(Stage.Skip.class, stage -> {
-            addProcessor(new MultiSkipProcessor<>(stage.getSkip()));
+            addProcessor(MultiSkipProcessor.create(stage.getSkip()));
         });
         registerStage(Stage.Distinct.class, stage -> {
-            addProcessor(new MultiDistinctProcessor<>());
+            addProcessor(MultiDistinctProcessor.create());
         });
         registerStage(Stage.FlatMap.class, stage -> {
             Function> pubMapper = o -> {
@@ -133,7 +131,7 @@ private GraphBuilder() {
             Subscriber subscriber = GraphBuilder.create()
                     .from(stage.getSubscriber()).getSubscriberWithCompletionStage().getSubscriber();
             Publisher publisher = GraphBuilder.create().from(stage.getPublisher()).getPublisher();
-            addProcessor(new MultiCoupledProcessor<>(HybridSubscriber.from(subscriber), HybridPublisher.from(publisher)));
+            addProcessor(MultiCoupledProcessor.create(HybridSubscriber.from(subscriber), HybridPublisher.from(publisher)));
         });
         registerStage(Stage.OnTerminate.class, stage -> {
             addProcessor(MultiTappedProcessor.create()
@@ -169,7 +167,8 @@ private GraphBuilder() {
             Subscriber subscriber = (Subscriber) stage.getRsSubscriber();
             RedeemingCompletionSubscriber completionSubscriber;
             if (subscriber instanceof CompletionSubscriber) {
-                completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, ((CompletionSubscriber) subscriber).getCompletion());
+                completionSubscriber = RedeemingCompletionSubscriber
+                        .of(subscriber, ((CompletionSubscriber) subscriber).getCompletion());
             } else {
                 completionSubscriber = RedeemingCompletionSubscriber.of(subscriber, new CompletableFuture<>());
             }
diff --git a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
index 0f220cc3867..fc4447673a6 100644
--- a/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
+++ b/microprofile/reactive-streams/src/test/java/io/helidon/microrofile/reactive/EngineTest.java
@@ -820,11 +820,11 @@ void mapOnError() throws InterruptedException, ExecutionException, TimeoutExcept
 
     @Test
     void finiteStream() throws InterruptedException, ExecutionException, TimeoutException {
-        finiteOnCompleteTest(new MultiPeekProcessor<>(integer -> Function.identity()));
-        finiteOnCompleteTest(new MultiFilterProcessor<>(integer -> true));
-        finiteOnCompleteTest(new MultiTakeWhileProcessor<>(integer -> true));
-        finiteOnCompleteTest(new MultiDropWhileProcessor<>(integer -> false));
-        finiteOnCompleteTest(new MultiSkipProcessor<>(0L));
+        finiteOnCompleteTest(MultiPeekProcessor.create(integer -> Function.identity()));
+        finiteOnCompleteTest(MultiFilterProcessor.create(integer -> true));
+        finiteOnCompleteTest(MultiTakeWhileProcessor.create(integer -> true));
+        finiteOnCompleteTest(MultiDropWhileProcessor.create(integer -> false));
+        finiteOnCompleteTest(MultiSkipProcessor.create(0L));
     }
 
     @Test

From 7d25ccf92f2bf458e104f670b4b61a2a5e4abbd3 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Tue, 7 Jan 2020 15:01:20 +0100
Subject: [PATCH 63/66] Multi PR review issues fix

  * Unusual method name fix
  * Copyright year

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BackPressureOverflowException.java      | 2 +-
 .../main/java/io/helidon/common/reactive/BaseProcessor.java | 6 +++---
 .../java/io/helidon/common/reactive/BufferedProcessor.java  | 2 +-
 .../java/io/helidon/common/reactive/ConcatPublisher.java    | 4 ++--
 .../src/main/java/io/helidon/common/reactive/Multi.java     | 2 +-
 .../io/helidon/common/reactive/MultiCoupledProcessor.java   | 6 +++---
 .../io/helidon/common/reactive/MultiDistinctProcessor.java  | 2 +-
 .../io/helidon/common/reactive/MultiDropWhileProcessor.java | 2 +-
 .../main/java/io/helidon/common/reactive/MultiEmpty.java    | 2 +-
 .../main/java/io/helidon/common/reactive/MultiError.java    | 2 +-
 .../io/helidon/common/reactive/MultiFilterProcessor.java    | 2 +-
 .../io/helidon/common/reactive/MultiFirstProcessor.java     | 2 +-
 .../io/helidon/common/reactive/MultiFlatMapProcessor.java   | 2 +-
 .../java/io/helidon/common/reactive/MultiFromPublisher.java | 2 +-
 .../io/helidon/common/reactive/MultiLimitProcessor.java     | 2 +-
 .../java/io/helidon/common/reactive/MultiMapProcessor.java  | 2 +-
 .../common/reactive/MultiOnErrorResumeProcessor.java        | 2 +-
 .../java/io/helidon/common/reactive/MultiPeekProcessor.java | 2 +-
 .../java/io/helidon/common/reactive/MultiSkipProcessor.java | 2 +-
 .../io/helidon/common/reactive/MultiTakeWhileProcessor.java | 2 +-
 .../io/helidon/common/reactive/MultiTappedProcessor.java    | 2 +-
 .../java/io/helidon/common/reactive/RequestedCounter.java   | 4 ++--
 .../io/helidon/common/reactive/StreamValidationUtils.java   | 6 +++---
 .../main/java/io/helidon/common/reactive/Subscribable.java  | 2 +-
 .../io/helidon/common/reactive/SubscriberReference.java     | 6 +++---
 .../src/test/java/io/helidon/common/reactive/MultiTest.java | 2 +-
 26 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
index a1c329af6ab..fc79ac88da2 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BackPressureOverflowException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
index 5dc5a88d7ec..78b16eee33c 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BaseProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,8 +55,8 @@ public BaseProcessor() {
 
     @Override
     public void request(long n) {
-        StreamValidationUtils.checkRequestParam309(n, this::failAndCancel);
-        StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> failAndCancel(t));
+        StreamValidationUtils.checkRequestParam(n, this::failAndCancel);
+        StreamValidationUtils.checkRecursionDepth(5, (actDepth, t) -> failAndCancel(t));
         requested.increment(n, this::failAndCancel);
         tryRequest(subscription);
         if (done) {
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
index 465342212c2..89a2ef05c93 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/BufferedProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
index 52fa18053b9..44eee17fee8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/ConcatPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -59,7 +59,7 @@ public void subscribe(Flow.Subscriber subscriber) {
         subscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
-                if (!StreamValidationUtils.checkRequestParam309(n, subscriber::onError)) {
+                if (!StreamValidationUtils.checkRequestParam(n, subscriber::onError)) {
                     return;
                 }
                 requested.set(n);
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
index 526345a8bf1..0450683d7cf 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Multi.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
index e182038f894..6fc0f0526fa 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiCoupledProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -124,7 +124,7 @@ public void onComplete() {
             @Override
             public void request(long n) {
                 // Request from outlet subscriber
-                StreamValidationUtils.checkRecursionDepth303(2, (actDepth, t) -> outletSubscriber.onError(t));
+                StreamValidationUtils.checkRecursionDepth(2, (actDepth, t) -> outletSubscriber.onError(t));
                 passedInPublisherSubscription.request(n);
             }
 
@@ -152,7 +152,7 @@ public void onSubscribe(Flow.Subscription inletSubscription) {
         passedInSubscriber.onSubscribe(new Flow.Subscription() {
             @Override
             public void request(long n) {
-                StreamValidationUtils.checkRecursionDepth303(5, (actDepth, t) -> passedInSubscriber.onError(t));
+                StreamValidationUtils.checkRecursionDepth(5, (actDepth, t) -> passedInSubscriber.onError(t));
                 inletSubscription.request(n);
             }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
index 5b1a231f6bd..220fdc0ee29 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDistinctProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
index ffb5550dc93..cbd80ddea3e 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiDropWhileProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiEmpty.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiEmpty.java
index c23ea4b1868..02678ad83ee 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiEmpty.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiEmpty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
index 76130466f67..d4ad542adf4 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiError.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
index 17cfdd2eaab..f417fea8f06 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFilterProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
index 7c82b036f5e..9ab96113fc4 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFirstProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
index d866e0372eb..bbefe5dd857 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFlatMapProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
index 9b6494120d2..7491b4b4f91 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiFromPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
index 382ec045864..22b0053d105 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiLimitProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
index 3927c1f79ed..5cf1b9a96ac 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiMapProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
index 3a18e3c5a03..62c5049764f 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiOnErrorResumeProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
index 3f0eee0bdd6..0169b935bd5 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiPeekProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
index 982373348f6..ac49095f55b 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiSkipProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
index 63eb311e32f..51525bc6aca 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTakeWhileProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
index 09d0b28abb1..b149974540a 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/MultiTappedProcessor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java b/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
index 0734f7f4d18..d0fa534f007 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/RequestedCounter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ public class RequestedCounter {
      * process errors
      */
     public void increment(long increment, Consumer errorHandler) {
-        if (!StreamValidationUtils.checkRequestParam309(increment, errorHandler)) {
+        if (!StreamValidationUtils.checkRequestParam(increment, errorHandler)) {
             return;
         }
 
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java b/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
index 471a1cb5e42..a2491165634 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/StreamValidationUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,7 +43,7 @@ private StreamValidationUtils() {
      * @return true if valid
      * @see reactive-streams/reactive-streams-jvm#3.3
      */
-    public static  boolean checkRecursionDepth303(int maxDepth, BiConsumer onExceeded) {
+    public static  boolean checkRecursionDepth(int maxDepth, BiConsumer onExceeded) {
         Long recursionDepth = getRecursionDepth();
         if (recursionDepth > maxDepth) {
             Optional.of(onExceeded)
@@ -68,7 +68,7 @@ public static  boolean checkRecursionDepth303(int maxDepth, BiConsumerreactive-streams/reactive-streams-jvm#3.9
      */
-    public static boolean checkRequestParam309(long requestParam, Consumer onExceeded) {
+    public static boolean checkRequestParam(long requestParam, Consumer onExceeded) {
         if (requestParam <= 0) {
             Optional.of(onExceeded)
                     .ifPresent(onExc -> onExc
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java b/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
index 0ff97a559b3..d5741a477d8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/Subscribable.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
index 0054b3f07c0..8ca5baf1af8 100644
--- a/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
+++ b/common/reactive/src/main/java/io/helidon/common/reactive/SubscriberReference.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c)  2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c)  2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,11 +27,11 @@ private SubscriberReference(Flow.Subscriber subscriber) {
         this.subscriber = Optional.of(subscriber);
     }
 
-    public static  SubscriberReference create(Flow.Subscriber subscriber) {
+    static  SubscriberReference create(Flow.Subscriber subscriber) {
         return new SubscriberReference<>(subscriber);
     }
 
-    public void releaseReference() {
+    void releaseReference() {
         this.subscriber = Optional.empty();
     }
 
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
index efcea98ff0a..cccf4382077 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/MultiTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From 17f83421445263680890195ff15bce944093c672 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 8 Jan 2020 11:17:48 +0100
Subject: [PATCH 64/66] Remove Valve oracle/helidon/issues/514

Signed-off-by: Daniel Kec 
---
 common/reactive/etc/spotbugs/exclude.xml      |  37 --
 common/reactive/pom.xml                       |   4 -
 .../reactive/valve/CloseableSupport.java      |  43 --
 .../common/reactive/valve/DetachedValve.java  |  94 -----
 .../common/reactive/valve/EmptyValve.java     |  46 ---
 .../reactive/valve/InputStreamValve.java      | 121 ------
 .../common/reactive/valve/IteratorValve.java  |  36 --
 .../common/reactive/valve/Pausable.java       |  33 --
 .../reactive/valve/PausableRegistry.java      | 149 -------
 .../common/reactive/valve/PublisherValve.java | 155 --------
 .../valve/RetryingPausableRegistry.java       |  50 ---
 .../helidon/common/reactive/valve/Tank.java   | 371 ------------------
 .../valve/UnorderedCollectorSupport.java      | 116 ------
 .../helidon/common/reactive/valve/Valve.java  | 234 -----------
 .../common/reactive/valve/ValveFilter.java    |  51 ---
 .../common/reactive/valve/ValveIterator.java  | 117 ------
 .../common/reactive/valve/ValvePublisher.java | 152 -------
 .../helidon/common/reactive/valve/Valves.java | 135 -------
 .../common/reactive/valve/package-info.java   |  25 --
 .../reactive/src/main/java/module-info.java   |   1 -
 .../reactive/valve/CloseableSupportTest.java  |  45 ---
 .../reactive/valve/InputStreamValveTest.java  | 214 ----------
 .../reactive/valve/IteratorValveTest.java     | 136 -------
 .../reactive/valve/PausableRegistryTest.java  | 123 ------
 .../reactive/valve/PublisherValveTest.java    |  86 ----
 .../common/reactive/valve/TankTest.java       | 143 -------
 .../common/reactive/valve/TestUtils.java      |  38 --
 .../valve/UnorderedCollectorSupportTest.java  |  70 ----
 .../reactive/valve/ValveIteratorTest.java     |  94 -----
 .../reactive/valve/ValvePublisherTest.java    | 224 -----------
 .../common/reactive/valve/ValveTest.java      | 171 --------
 .../common/reactive/valve/ValvesTest.java     |  62 ---
 32 files changed, 3376 deletions(-)
 delete mode 100644 common/reactive/etc/spotbugs/exclude.xml
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/CloseableSupport.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/DetachedValve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/EmptyValve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/InputStreamValve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/IteratorValve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/Pausable.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/PausableRegistry.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/PublisherValve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/RetryingPausableRegistry.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/Tank.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/UnorderedCollectorSupport.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/Valve.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveFilter.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveIterator.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/ValvePublisher.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/Valves.java
 delete mode 100644 common/reactive/src/main/java/io/helidon/common/reactive/valve/package-info.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/CloseableSupportTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/InputStreamValveTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/IteratorValveTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/PausableRegistryTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/PublisherValveTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/TankTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/TestUtils.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/UnorderedCollectorSupportTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveIteratorTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvePublisherTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveTest.java
 delete mode 100644 common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvesTest.java

diff --git a/common/reactive/etc/spotbugs/exclude.xml b/common/reactive/etc/spotbugs/exclude.xml
deleted file mode 100644
index 201268dc797..00000000000
--- a/common/reactive/etc/spotbugs/exclude.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-
-
-
-    
-        
-        
-        
-        
-    
-
-    
-        
-        
-        
-    
-
diff --git a/common/reactive/pom.xml b/common/reactive/pom.xml
index 8b3d103b2e9..9a000ab61a5 100644
--- a/common/reactive/pom.xml
+++ b/common/reactive/pom.xml
@@ -28,10 +28,6 @@
     helidon-common-reactive
     Helidon Common Reactive
 
-    
-        etc/spotbugs/exclude.xml
-    
-
     
         
             
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/CloseableSupport.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/CloseableSupport.java
deleted file mode 100644
index 8ba3d91415f..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/CloseableSupport.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-/**
- * Can be closed and has information about the state.
- * 
    
- * The goal is to provide just enough synchronisation.
- */
-class CloseableSupport implements AutoCloseable {
-
-    private boolean closed = false;
-    private volatile boolean closedVolatile = false;
-
-    @Override
-    public void close() {
-        closed = true;
-        closedVolatile = true;
-    }
-
-    /**
-     * Returns {@code true} if it is closed.
-     *
-     * @return {@code true} if it is closed
-     */
-    boolean closed() {
-        return closed || closedVolatile;
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/DetachedValve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/DetachedValve.java
deleted file mode 100644
index 2ca5f6bd7e8..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/DetachedValve.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-class DetachedValve implements Valve {
-
-    private static final int INTERNAL_INDEX = 0;
-    private static final int EXTERNAL_INDEX = 1;
-
-    private final boolean[] paused = new boolean[] {false, false};
-
-    private final Lock lock = new ReentrantLock();
-    private final Valve delegate;
-    private final ExecutorService executorService;
-
-    DetachedValve(Valve delegate, ExecutorService executorService) {
-        this.delegate = delegate;
-        this.executorService = executorService;
-    }
-
-    @Override
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        delegate.handle((t, p) -> {
-                            pause(INTERNAL_INDEX);
-                            CompletableFuture.runAsync(() -> onData.accept(t, this), executorService)
-                                             .whenComplete((vd, thr) -> {
-                                                 if (thr == null) {
-                                                     resume(INTERNAL_INDEX);
-                                                 } else {
-                                                     executorService.submit(() -> onError.accept(thr));
-                                                 }
-                                             });
-                        },
-                        t -> executorService.submit(() -> onError.accept(t)),
-                        () -> executorService.submit(onComplete));
-    }
-
-    private void pause(int index) {
-        lock.lock();
-        try {
-            boolean callIt = !paused[0] && !paused[1];
-            paused[index] = true;
-            if (callIt) {
-                delegate.pause();
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    private void resume(int index) {
-        lock.lock();
-        try {
-            boolean callIt = paused[index] && !paused[index == 0 ? 1 : 0];
-            paused[index] = false;
-            if (callIt) {
-                delegate.resume();
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    @Override
-    public void pause() {
-        pause(EXTERNAL_INDEX);
-    }
-
-    @Override
-    public void resume() {
-        resume(EXTERNAL_INDEX);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/EmptyValve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/EmptyValve.java
deleted file mode 100644
index 113549c99df..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/EmptyValve.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-/**
- * Represents a Valve which is empty.
- * 
    
- * For the performance sake the Valve accepts unlimited number of handlers.
- * Each complete handler is called as soon as registered.
- */
-class EmptyValve implements Valve {
-
-    @Override
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        if (onComplete != null) {
-            onComplete.run();
-        }
-    }
-
-    @Override
-    public void pause() {
-        // No-op
-    }
-
-    @Override
-    public void resume() {
-        // No-op
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/InputStreamValve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/InputStreamValve.java
deleted file mode 100644
index 3802fe4c4bd..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/InputStreamValve.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.ByteBuffer;
-import java.nio.channels.Channels;
-import java.nio.channels.WritableByteChannel;
-import java.nio.charset.Charset;
-import java.util.concurrent.ExecutorService;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-
-/**
- * The InputStreamValve is a {@link ByteBuffer} based {@link Valve} that transforms
- * a possibly blocking {@link InputStream} into the Valve.
- */
-public class InputStreamValve extends RetryingPausableRegistry implements Valve {
-    private final InputStream stream;
-    private final int bufferSize;
-
-    InputStreamValve(InputStream stream, int bufferSize) {
-        this.stream = stream;
-        this.bufferSize = bufferSize;
-    }
-
-    @Override
-    protected ByteBuffer moreData() throws Throwable {
-        byte[] bytes = new byte[bufferSize];
-
-        int len = stream.read(bytes);
-        return len != -1 ? ByteBuffer.wrap(bytes, 0, len) : null;
-    }
-
-    static class InputStreamExecutorValve extends InputStreamValve {
-
-        private final ExecutorService executorService;
-
-        InputStreamExecutorValve(InputStream stream, int bufferSize, ExecutorService executorService) {
-            super(stream, bufferSize);
-            this.executorService = executorService;
-        }
-
-        @Override
-        protected void tryProcess() {
-            executorService.submit(() -> {
-                super.tryProcess();
-            });
-        }
-    }
-
-    /**
-     * A collector of {@link ByteBuffer} instances into a {@link String} of the provided
-     * charset.
-     *
-     * @param charset the desired charset of the returned string
-     * @return a string representation of the collected byte buffers
-     */
-    public static Collector byteBufferStringCollector(Charset charset) {
-        return Collectors.collectingAndThen(byteBufferByteArrayCollector(), bytes -> new String(bytes, charset));
-    }
-
-    /**
-     * A collector of {@link ByteBuffer} instances into a single {@link ByteBuffer} instance.
-     *
-     * @return a single byte buffer from the collected byte buffers
-     */
-    public static Collector byteBuffer2Collector() {
-        return Collectors.collectingAndThen(byteBufferByteArrayCollector(), ByteBuffer::wrap);
-    }
-
-    /**
-     * A collector of {@link ByteBuffer} instances into a single byte array.
-     *
-     * @return a single byte array from the collected byte buffers
-     */
-    public static Collector byteBufferByteArrayCollector() {
-
-        return Collector.of(ByteArrayOutputStream::new,
-                            (stream, byteBuffer) -> {
-                                try {
-                                    synchronized (stream) {
-                                        WritableByteChannel channel = Channels.newChannel(stream);
-                                        channel.write(byteBuffer);
-                                    }
-                                } catch (IOException e) {
-                                    // not expected to be thrown because we're operating in memory only
-                                    throw new IllegalStateException("This exception is never expected.", e);
-                                }
-                            },
-                            (stream, stream2) -> {
-                                try {
-                                    synchronized (stream) {
-                                        stream2.writeTo(stream);
-                                    }
-                                    return stream;
-                                } catch (IOException e) {
-                                    // not expected to be thrown because we're operating in memory only
-                                    throw new IllegalStateException("This exception is never expected.", e);
-                                }
-                            },
-                            ByteArrayOutputStream::toByteArray);
-    }
-
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/IteratorValve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/IteratorValve.java
deleted file mode 100644
index 1dcd05042e7..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/IteratorValve.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Iterator;
-
-/**
- * The {@link Valve} implementation for {@link Iterator}.
- */
-class IteratorValve extends RetryingPausableRegistry implements Valve {
-
-    private final Iterator iterator;
-
-    IteratorValve(Iterator iterator) {
-        this.iterator = iterator;
-    }
-
-    @Override
-    protected T moreData() {
-        return iterator.hasNext() ? iterator.next() : null;
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Pausable.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/Pausable.java
deleted file mode 100644
index dc2cbd249d7..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Pausable.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-/**
- * A simple {@link #pause() pause} / {@link #resume() resume} interface.
- */
-public interface Pausable {
-
-    /**
-     * Pause data chunks flow until {@link #resume()}.
-     */
-    void pause();
-
-    /**
-     * Resume data chunks flow after {@link #pause()}.
-     */
-    void resume();
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/PausableRegistry.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/PausableRegistry.java
deleted file mode 100644
index 3da2cbcf17e..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/PausableRegistry.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Objects;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * Supports {@link Valve} implementation by providing single handler registry
- * and pause / resume functionality with facility tryProcess reservation.
- */
-abstract class PausableRegistry implements Pausable {
-
-    private static final Logger LOGGER = Logger.getLogger(PausableRegistry.class.getName());
-
-    private final ReentrantLock lock = new ReentrantLock();
-
-    private volatile BiConsumer onData;
-    private volatile Consumer onError;
-    private volatile Runnable onComplete;
-
-    private volatile boolean paused = false;
-    private boolean processing = false;
-
-    @Override
-    public void pause() {
-        paused = true;
-    }
-
-    @Override
-    public void resume() {
-        paused = false;
-        tryProcess();
-    }
-
-    /**
-     * Implements item handling / processing. Implementation can use {@link #canProcess()} and {@link #canContinueProcessing()}
-     * method to ensure, that processing is done by a single thread at a time.
-     */
-    protected abstract void tryProcess();
-
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        Objects.requireNonNull(onData, "Parameter onData is null!");
-        synchronized (this) {
-            if (this.onData != null) {
-                throw new IllegalStateException("Handler is already registered!");
-            }
-            this.onData = onData;
-            this.onError = onError;
-            this.onComplete = onComplete;
-        }
-        resume();
-    }
-
-    /**
-     * Implementation of {@link #tryProcess()} method should call this to reserve initial handle processing (if possible).
-     * The same method should call {@link #canContinueProcessing()} before every iteration to be sure, that handle processing
-     * should continue.
-     *
-     * @return {@code true} only if method can process (handle) item
-     */
-    protected boolean canProcess() {
-        if (onData == null) {
-            return false;
-        }
-        lock.lock();
-        try {
-            if (paused || processing) {
-                return false;
-            } else {
-                processing = true;
-                return true;
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Implementation of {@link #tryProcess()} which initially was accepted by {@link #canProcess()} should call this method
-     * before every iteration to be sure, that processing can continue (is not paused).
-     *
-     * @return {@code true} only if method can continue with handle processing
-     */
-    protected boolean canContinueProcessing() {
-        if (paused) {
-            lock.lock();
-            try {
-                processing = false;
-            } finally {
-                lock.unlock();
-            }
-            return false;
-        } else {
-            return true;
-        }
-    }
-
-    protected boolean paused() {
-        return paused;
-    }
-
-    protected void releaseProcessing() {
-        lock.lock();
-        try {
-            processing = false;
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    protected void handleError(Throwable thr) {
-        if (onError != null) {
-            onError.accept(thr);
-        } else {
-            LOGGER.log(Level.WARNING, "Unhandled throwable!", thr);
-        }
-    }
-
-    protected BiConsumer getOnData() {
-        return onData;
-    }
-
-    protected Consumer getOnError() {
-        return onError;
-    }
-
-    protected Runnable getOnComplete() {
-        return onComplete;
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/PublisherValve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/PublisherValve.java
deleted file mode 100644
index dd108681d51..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/PublisherValve.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Objects;
-import java.util.concurrent.Flow;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * The {@link Valve} implementation on top of {@link java.util.concurrent.Flow.Publisher}.
- *
- * @param  Type of {@code Valve} and {@code Publisher} items
- */
-class PublisherValve implements Valve {
-
-    private static final Logger LOGGER = Logger.getLogger(PublisherValve.class.getName());
-
-    private final ReentrantLock lock = new ReentrantLock();
-    private final Flow.Publisher publisher;
-
-    private volatile Subscriber subscriber;
-    private volatile boolean paused = false;
-
-    private boolean recordedDemand = false;
-
-    /**
-     * Creates new instance.
-     *
-     * @param publisher a publisher as a base of this {@code Valve}
-     */
-    PublisherValve(Flow.Publisher publisher) {
-        Objects.requireNonNull(publisher, "Parameter 'publisher' is null!");
-        this.publisher = publisher;
-    }
-
-    @Override
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        synchronized (this) {
-            if (this.subscriber != null) {
-                throw new IllegalStateException("Handler is already registered!");
-            }
-            this.subscriber = new Subscriber(onData, onError, onComplete);
-        }
-        this.paused = false;
-        publisher.subscribe(this.subscriber);
-    }
-
-    @Override
-    public void pause() {
-        lock.lock();
-        try {
-            this.paused = true;
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    @Override
-    public void resume() {
-        boolean processDemand = false;
-        lock.lock();
-        try {
-            if (paused && subscriber != null) {
-                paused = false;
-                if (recordedDemand) {
-                    processDemand = true;
-                    recordedDemand = false;
-                }
-            }
-        } finally {
-            lock.unlock();
-            if (processDemand) {
-                subscriber.subscription.request(1);
-            }
-        }
-    }
-
-    private boolean recordDemand() {
-        lock.lock();
-        try {
-            if (paused) {
-                this.recordedDemand = true;
-                return true;
-            } else {
-                return false;
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    private class Subscriber implements Flow.Subscriber {
-
-        private final BiConsumer onData;
-        private final Consumer onError;
-        private final Runnable onComplete;
-
-        private volatile Flow.Subscription subscription;
-
-        Subscriber(BiConsumer onData, Consumer onError, Runnable onComplete) {
-            Objects.requireNonNull(onData, "Parameter 'onData' is null!");
-            this.onData = onData;
-            this.onError = onError;
-            this.onComplete = onComplete;
-        }
-
-        @Override
-        public void onSubscribe(Flow.Subscription subscription) {
-            this.subscription = subscription;
-            subscription.request(1);
-        }
-
-        @Override
-        public void onNext(T item) {
-            onData.accept(item, PublisherValve.this);
-            if (!paused || !recordDemand()) {
-                subscription.request(1);
-            }
-        }
-
-        @Override
-        public void onError(Throwable throwable) {
-            if (onError != null) {
-                onError.accept(throwable);
-            } else {
-                LOGGER.log(Level.WARNING, "Unhandled throwable!", throwable);
-            }
-        }
-
-        @Override
-        public void onComplete() {
-            if (onComplete != null) {
-                onComplete.run();
-            }
-        }
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/RetryingPausableRegistry.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/RetryingPausableRegistry.java
deleted file mode 100644
index f6064557485..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/RetryingPausableRegistry.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.function.BiConsumer;
-
-/**
- * The RetryingPausableRegistry.
- */
-abstract class RetryingPausableRegistry extends PausableRegistry {
-    @Override
-    protected void tryProcess() {
-        if (canProcess()) {
-            try {
-                BiConsumer onData = getOnData();
-                boolean breakByPause = false;
-                T data;
-                while ((data = moreData()) != null) {
-                    onData.accept(data, this);
-                    if (!canContinueProcessing()) {
-                        breakByPause = true;
-                        break;
-                    }
-                }
-                if (!breakByPause && getOnComplete() != null) {
-                    getOnComplete().run();
-                }
-            } catch (Throwable thr) {
-                handleError(thr);
-                releaseProcessing();
-            }
-        }
-    }
-
-    protected abstract T moreData() throws Throwable;
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Tank.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/Tank.java
deleted file mode 100644
index 0ea84e6431a..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Tank.java
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Objects;
-import java.util.Queue;
-import java.util.Spliterator;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingDeque;
-import java.util.concurrent.TimeUnit;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * Tank of events is a closeable FIFO queue with a limited size implementing {@link Valve} reactive API.
- *
- * @param  a type of items produced by {@code Valve} API
- */
-public class Tank implements Valve, BlockingQueue, AutoCloseable {
-
-    private final int capacity;
-    private final CloseableSupport closeableSupport = new CloseableSupport();
-    private final Queue drainHandlers = new LinkedBlockingDeque<>();
-    private final PausableRegistry registry = new PausableRegistry() {
-        @Override
-        protected void tryProcess() {
-            Tank.this.tryProcess();
-        }
-    };
-    private final ThreadLocal inDrainHandler = ThreadLocal.withInitial(() -> Boolean.FALSE);
-    private final ArrayBlockingQueue queue;
-
-    /**
-     * Creates new instance.
-     *
-     * @param capacity the capacity of this queue
-     */
-    public Tank(int capacity) {
-        this.capacity = capacity;
-        queue = new ArrayBlockingQueue<>(capacity, true);
-    }
-
-    /**
-     * Provided handler is called a single time when internal capacity is maximally half full and instance is not closed.
-     *
-     * @param drainHandler an handler of drain event
-     * @throws NullPointerException if {@code drainHandler} is {@code null}
-     */
-    public void whenDrain(Runnable drainHandler) {
-        Objects.requireNonNull(drainHandler, "Parameter 'drainHandler' is null!");
-        checkClosed();
-        if (!inDrainHandler.get() && remainingCapacity() >= (capacity / 2)) {
-            inDrainHandler.set(true);
-            try {
-                drainHandler.run();
-            } finally {
-                inDrainHandler.set(false);
-            }
-        } else {
-            drainHandlers.add(drainHandler);
-        }
-    }
-
-    // ----- Valve implementation
-
-    @Override
-    public void pause() {
-        registry.pause();
-    }
-
-    @Override
-    public void resume() {
-        registry.resume();
-    }
-
-    @Override
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        registry.handle(onData, onError, onComplete);
-    }
-
-    private void tryProcess() {
-        if (registry.canProcess()) {
-            boolean breakByPause = false;
-            try {
-                BiConsumer onData = registry.getOnData();
-                T t;
-                while ((t = poll()) != null) {
-                    onData.accept(t, this);
-                    if (registry.paused()) {
-                        breakByPause = true;
-                        break;
-                    }
-                }
-            } catch (Exception e) {
-                registry.handleError(e);
-            } finally {
-                if (!breakByPause && closeableSupport.closed()) {
-                    // Handle close
-                    Runnable onComplete = registry.getOnComplete();
-                    if (onComplete != null) {
-                        onComplete.run();
-                    }
-                }
-                registry.releaseProcessing();
-            }
-            processDrainHandlers();
-        }
-    }
-
-    private void processDrainHandlers() {
-        while (!inDrainHandler.get() && !closeableSupport.closed() && remainingCapacity() >= (capacity / 2)) {
-            Runnable hndlr = drainHandlers.poll();
-            if (hndlr != null) {
-                inDrainHandler.set(true);
-                try {
-                    hndlr.run();
-                } finally {
-                    inDrainHandler.set(false);
-                }
-            } else {
-                break;
-            }
-        }
-    }
-
-    // ----- AutoCloseable
-
-    @Override
-    public void close() {
-        closeableSupport.close();
-        tryProcess();
-    }
-
-    private void checkClosed() {
-        if (closeableSupport.closed()) {
-            throw new IllegalStateException("Tank instance is closed!");
-        }
-    }
-
-    // ----- Insert methods
-
-    @Override
-    public boolean add(T t) {
-        checkClosed();
-        boolean result = queue.add(t);
-        tryProcess();
-        return result;
-    }
-
-    @Override
-    public boolean addAll(Collection c) {
-        checkClosed();
-        boolean result = queue.addAll(c);
-        tryProcess();
-        return result;
-    }
-
-    @Override
-    public boolean offer(T t) {
-        if (closeableSupport.closed()) {
-            return false;
-        }
-        boolean result = queue.offer(t);
-        if (result) {
-            tryProcess();
-        }
-        return result;
-    }
-
-    /**
-     * Inserts the specified element at the tail of this queue, waiting
-     * for space to become available if the queue is full.
-     *
-     * @throws InterruptedException {@inheritDoc}
-     * @throws NullPointerException {@inheritDoc}
-     * @throws IllegalArgumentException if Tank is closed
-     */
-    @Override
-    public void put(T t) throws InterruptedException {
-        checkClosed();
-        queue.put(t);
-        tryProcess();
-    }
-
-    @Override
-    public boolean offer(T t, long timeout, TimeUnit unit) throws InterruptedException {
-        if (closeableSupport.closed()) {
-            return false;
-        }
-        boolean result = queue.offer(t, timeout, unit);
-        if (result) {
-            tryProcess();
-        }
-        return result;
-    }
-
-    // ----- Remove methods
-
-    @Override
-    public void clear() {
-        queue.clear();
-    }
-
-    @Override
-    public T poll() {
-        T t = queue.poll();
-        if (t != null) {
-            processDrainHandlers();
-        }
-        return t;
-    }
-
-    @Override
-    public T take() throws InterruptedException {
-        T t = queue.take();
-        processDrainHandlers();
-        return t;
-    }
-
-    @Override
-    public T poll(long timeout, TimeUnit unit) throws InterruptedException {
-        T t = queue.poll(timeout, unit);
-        if (t != null) {
-            processDrainHandlers();
-        }
-        return t;
-    }
-
-    @Override
-    public boolean remove(Object o) {
-        boolean result = queue.remove(o);
-        if (result) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public int drainTo(Collection c) {
-        int result = queue.drainTo(c);
-        if (result > 0) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public int drainTo(Collection c, int maxElements) {
-        int result = queue.drainTo(c, maxElements);
-        if (result > 0) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public boolean removeIf(Predicate filter) {
-        boolean result = queue.removeIf(filter);
-        if (result) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public boolean removeAll(Collection c) {
-        boolean result = queue.removeAll(c);
-        if (result) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public boolean retainAll(Collection c) {
-        boolean result = queue.retainAll(c);
-        if (result) {
-            processDrainHandlers();
-        }
-        return result;
-    }
-
-    @Override
-    public T remove() {
-        T t = queue.remove();
-        if (t != null) {
-            processDrainHandlers();
-        }
-        return t;
-    }
-
-    // ----- Query methods (delegated only)
-
-    @Override
-    public T element() {
-        return queue.element();
-    }
-
-    @Override
-    public T peek() {
-        return queue.peek();
-    }
-
-    @Override
-    public int size() {
-        return queue.size();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return queue.isEmpty();
-    }
-
-    @Override
-    public int remainingCapacity() {
-        return queue.remainingCapacity();
-    }
-
-    @Override
-    public boolean containsAll(Collection c) {
-        return false;
-    }
-
-    @Override
-    public boolean contains(Object o) {
-        return queue.contains(o);
-    }
-
-    @Override
-    public Object[] toArray() {
-        return queue.toArray();
-    }
-
-    @Override
-    public  T1[] toArray(T1[] a) {
-        return queue.toArray(a);
-    }
-
-    @Override
-    public Iterator iterator() {
-        return queue.iterator();
-    }
-
-    @Override
-    public Spliterator spliterator() {
-        return queue.spliterator();
-    }
-
-    @Override
-    public void forEach(Consumer action) {
-        queue.forEach(action);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/UnorderedCollectorSupport.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/UnorderedCollectorSupport.java
deleted file mode 100644
index d11247e3e53..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/UnorderedCollectorSupport.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.function.BinaryOperator;
-import java.util.stream.Collector;
-
-/**
- * Use {@link java.util.stream.Collector} with {@code UNORDERED} characteristic to
- * collect data from {@link Valve}.
- * 
    
- * Implementation use {@link ThreadLocal} to decrease synchronization demand.
- */
-class UnorderedCollectorSupport {
-
-    private static final int CONCURRENCY_LIMIT = 256;
-
-    private final Collector collector;
-    private final CompletableFuture resultFuture = new CompletableFuture<>();
-    private final ThreadLocal intermediate = new ThreadLocal<>();
-    private final List intermediates = new ArrayList<>(16);
-
-    private A sharedIntermediate;
-
-    /**
-     * Creates new instance.
-     *
-     * @param collector a collector with {@code UNORDERED} characteristic to use
-     * @throws NullPointerException if {@code collector} parameter is {@code null}
-     * @throws IllegalArgumentException if {@code collector} doesn't have {@code UNORDERED} characteristic.
-     */
-    UnorderedCollectorSupport(Collector collector) {
-        Objects.requireNonNull(collector, "Parameter 'collector' is null");
-        if (!collector.characteristics().contains(Collector.Characteristics.UNORDERED)) {
-            throw new IllegalArgumentException("Collector parameter must have 'UNORDERED' characteristic.");
-        }
-        this.collector = collector;
-    }
-
-    /**
-     * Returns a result which will be completed when {@link #complete()} or {@link #completeExceptionally(Throwable)}
-     * is called.
-     *
-     * @return a completion stage of the result
-     */
-    CompletionStage getResult() {
-        return resultFuture;
-    }
-
-    /**
-     * Add an item using collector.
-     *
-     * @param item a item to add
-     */
-    void add(T item) {
-        A a = intermediate.get();
-        if (a == null) {
-            synchronized (intermediates) {
-                if (intermediates.size() < CONCURRENCY_LIMIT) {
-                    // Add an intermediate
-                    a = collector.supplier().get();
-                    intermediate.set(a);
-                    intermediates.add(a);
-                } else {
-                    if (sharedIntermediate == null) {
-                        sharedIntermediate = collector.supplier().get();
-                        intermediates.add(sharedIntermediate);
-                    }
-                    collector.accumulator().accept(sharedIntermediate, item);
-                    return;
-                }
-            }
-        }
-        // Add item
-        collector.accumulator().accept(a, item);
-    }
-
-    @SuppressWarnings("unchecked")
-    void complete() {
-        synchronized (intermediates) {
-            BinaryOperator combiner = collector.combiner();
-            A a = intermediates.isEmpty() ? collector.supplier().get() : intermediates.get(0);
-            for (int i = 1; i < intermediates.size(); i++) {
-                a = combiner.apply(a, intermediates.get(i));
-            }
-            if (collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
-                resultFuture.complete((R) a);
-            } else {
-                resultFuture.complete(collector.finisher().apply(a));
-            }
-        }
-    }
-
-    void completeExceptionally(Throwable t) {
-        resultFuture.completeExceptionally(t);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valve.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valve.java
deleted file mode 100644
index 96e35349af2..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valve.java
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Flow;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collector;
-
-/**
- * Represents a reactive source of data which can be {@link #pause() paused} and {@link #resume() resumed}.
- *
- * @param  a type of items produced by {@code Valve} API
- */
-public interface Valve extends Pausable {
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData     a callback for data chunks and {@link Pausable} representing a faucet of this {@link Valve}.
-     * @param onError    a callback of errors or {@code null}
-     * @param onComplete a callback for completion event or {@code null}
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    void handle(BiConsumer onData, Consumer onError, Runnable onComplete);
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData a callback for data chunks and {@link Pausable} representing a faucet of this {@link Valve}.
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    default void handle(BiConsumer onData) {
-        handle(onData, null, null);
-    }
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData  a callback for data chunks and {@link Pausable} representing a faucet of this {@link Valve}.
-     * @param onError a callback of errors or {@code null}
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    default void handle(BiConsumer onData, Consumer onError) {
-        handle(onData, onError, null);
-    }
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData     a callback for data chunks.
-     * @param onError    a callback of errors or {@code null}
-     * @param onComplete a callback for completion event or {@code null}
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    default void handle(Consumer onData, Consumer onError, Runnable onComplete) {
-        handle((t, p) -> onData.accept(t), onError, onComplete);
-    }
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData a callback for data chunks.
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    default void handle(Consumer onData) {
-        handle(onData, null, null);
-    }
-
-    /**
-     * Register data handlers (callbacks).
-     *
-     * @param onData  a callback for data chunks.
-     * @param onError a callback of errors or {@code null}
-     * @throws NullPointerException  if {@code onData} parameter is {@code null}
-     * @throws IllegalStateException if cannot register new callback. For example if instance accepts only a single handler.
-     */
-    default void handle(Consumer onData, Consumer onError) {
-        handle(onData, onError, null);
-    }
-
-    /**
-     * Returns a {@link Valve} consisting of the results of applying the given function to the elements of this {@link Valve}.
-     *
-     * @param     the element type of the new {@link Valve}
-     * @param mapper a stateless function to apply to each element
-     * @return the new {@code Valve}
-     */
-    default  Valve map(Function mapper) {
-        return new ValveFilter<>(this, onData -> (t, p) -> onData.accept(mapper.apply(t), p));
-    }
-
-    /**
-     * Returns new {@code Valve} instance which combines all results into a single Valve.
-     * 
    
-     * If provided {@code mapFunction} returns {@code null} then this result is skipped.
-     *
-     * @param mapFunction maps an element into new {@link Valve} instance.
-     * @param          the element type of the new {@link Valve}
-     * @return the new {@code Valve}
-     */
-    default  Valve flatMap(Function> mapFunction) {
-        throw new UnsupportedOperationException("Not implemented!");
-    }
-
-    /**
-     * Returns a {@link Valve} consisting of the elements of this {@link Valve} that match the given predicate.
-     *
-     * @param predicate a stateless predicate to apply to each element to determine if it should be included
-     * @return the new {@code Valve}
-     */
-    default Valve filter(Predicate predicate) {
-        return new ValveFilter<>(this, onData -> (t, p) -> {
-            if (predicate.test(t)) {
-                onData.accept(t, p);
-            }
-        });
-    }
-
-    /**
-     * Returns a {@link Valve} consisting of the elements of this {@link Valve}, additionally
-     * performing the provided action on each element as elements are consumed from the resulting {@link Valve}.
-     *
-     * @param action an action to perform on the elements as they are consumed from the {@code Valve}
-     * @return the new {@code Valve}
-     */
-    default Valve peek(Consumer action) {
-        return new ValveFilter<>(this, onData -> (element, p) -> {
-            action.accept(element);
-            onData.accept(element, p);
-        });
-    }
-
-    /**
-     * Returns a {@link CompletionStage} which will be completed when this {@link Valve} is completed and result is a collected
-     * value.
-     * 
    
-     * Result completes exceptionally if this {@code Valve} completes exceptionally.
-     *
-     * @param collector a collector to use
-     * @param        the intermediate accumulation type of the {@code Collector}
-     * @param        the type of the result
-     * @return a completion stage of collected result
-     */
-    default  CompletionStage collect(Collector collector) {
-        Set characteristics = collector.characteristics();
-        if (characteristics.contains(Collector.Characteristics.CONCURRENT)) {
-            A intermediateCollection = collector.supplier().get();
-            BiConsumer accumulator = collector.accumulator();
-            CompletableFuture result = new CompletableFuture<>();
-            handle(item -> accumulator.accept(intermediateCollection, item),
-                   result::completeExceptionally,
-                   () -> result.complete(collector.finisher().apply(intermediateCollection)));
-            return result;
-        } else if (characteristics.contains(Collector.Characteristics.UNORDERED)) {
-            UnorderedCollectorSupport support = new UnorderedCollectorSupport<>(collector);
-            handle(support::add, support::completeExceptionally, support::complete);
-            return support.getResult();
-        } else {
-            A intermediateCollection = collector.supplier().get();
-            BiConsumer accumulator = collector.accumulator();
-            CompletableFuture result = new CompletableFuture<>();
-            handle(item -> {
-                       synchronized (intermediateCollection) {
-                           accumulator.accept(intermediateCollection, item);
-                       }
-                   },
-                   result::completeExceptionally,
-                   () -> result.complete(collector.finisher().apply(intermediateCollection)));
-            return result;
-        }
-    }
-
-    /**
-     * Transforms this {@code Valve} into {@link java.util.concurrent.Flow.Publisher} representation. Resulting {@code
-     * Publisher}
-     * accepts only single {@link java.util.concurrent.Flow.Subscriber}.
-     *
-     * @return a {@code Publisher} representation
-     */
-    default Flow.Publisher toPublisher() {
-        return new ValvePublisher<>(this);
-    }
-
-    /**
-     * Returns new {@code Valve} which defer all handlers to provided {@link ExecutorService}. Each data chunk will
-     * be still called sequentially.
-     *
-     * @param executorService an executor service to use
-     * @return a new {@code Valve} instance
-     * @throws NullPointerException if {@code executorService} parameter is {@code null}.
-     */
-    default Valve executeOn(ExecutorService executorService) {
-        Objects.requireNonNull(executorService, "Parameter 'executorService' is null!");
-        return new DetachedValve<>(this, executorService);
-    }
-
-    /**
-     * Transforms this {@code Valve} into {@link ValveIterator} representation. It transforms reactive approach to the blocking
-     * polling {@link java.util.Iterator} API.
-     *
-     * @return an iterator instance
-     * @throws IllegalStateException if this instance has already registered handlers
-     */
-    default ValveIterator toIterator() {
-        return new ValveIterator<>(this);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveFilter.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveFilter.java
deleted file mode 100644
index 9052658ef55..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveFilter.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-/**
- * Delegate filter for {@link Valve}.
- */
-class ValveFilter implements Valve {
-
-    private final Valve delegate;
-    private final Function, BiConsumer> filteringFunction;
-
-    ValveFilter(Valve delegate,
-                Function, BiConsumer> filteringFunction) {
-        this.delegate = delegate;
-        this.filteringFunction = filteringFunction;
-    }
-
-    @Override
-    public void pause() {
-        delegate.pause();
-    }
-
-    @Override
-    public void resume() {
-        delegate.resume();
-    }
-
-    @Override
-    public void handle(BiConsumer onData, Consumer onError, Runnable onComplete) {
-        delegate.handle(filteringFunction.apply(onData), onError, onComplete);
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveIterator.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveIterator.java
deleted file mode 100644
index a14f084dd3b..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValveIterator.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.logging.Logger;
-
-/**
- * Transforms reactive {@link Valve} into a blocking {@link Iterator}.
- * 
    
- * If the original {@code Valve} ends with {@code Throwable} then this iterator simply ends and original cause can be get
- * using {@link #getThrowable()} method.
- *
- * @param  Type of elements
- */
-public class ValveIterator implements Iterator {
-
-    private static final Logger LOGGER = Logger.getLogger(ValveIterator.class.getName());
-
-    private final Object lock = new Object();
-    private final Valve valve;
-    private boolean closed = false;
-    private T nextItem;
-    private volatile Throwable throwable;
-
-    ValveIterator(Valve valve) {
-        this.valve = valve;
-        valve.handle((t, p) -> {
-            synchronized (lock) {
-                nextItem = t;
-                p.pause();
-                lock.notifyAll();
-            }
-        }, throwable -> {
-            this.throwable = throwable;
-            close();
-        }, this::close);
-    }
-
-    private void close() {
-        synchronized (lock) {
-            closed = true;
-            lock.notifyAll();
-        }
-    }
-
-    @Override
-    public boolean hasNext() {
-        synchronized (lock) {
-            if (nextItem != null) {
-                return true;
-            }
-            if (closed) {
-                return false;
-            }
-            while (true) {
-                valve.resume();
-                if (nextItem != null) {
-                    return true;
-                }
-                if (closed) {
-                    return false;
-                }
-                try {
-                    lock.wait();
-                    if (nextItem != null) {
-                        return true;
-                    }
-                    if (closed) {
-                        return false;
-                    }
-                } catch (InterruptedException e) {
-                    this.closed = true;
-                    this.throwable = e;
-                    return false;
-                }
-            }
-        }
-    }
-
-    @Override
-    public T next() {
-        synchronized (lock) {
-            if (hasNext()) {
-                T result = nextItem;
-                nextItem = null;
-                return result;
-            } else {
-                throw new NoSuchElementException("No more elements. Original Valve is closed!");
-            }
-        }
-    }
-
-    /**
-     * If original {@link Valve} ends with error then this method returns cause of such error.
-     *
-     * @return the cause of {@code Valve} error or {@code null}
-     */
-    public Throwable getThrowable() {
-        return throwable;
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValvePublisher.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValvePublisher.java
deleted file mode 100644
index fef0b6b3dd6..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/ValvePublisher.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.concurrent.Flow;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-/**
- * The ValvePublisher provides {@link java.util.concurrent.Flow.Publisher} based API for the {@link Valve}.
- * This publisher accepts only a single subscriber.
- *
- * @param  the type of items to be published
- */
-class ValvePublisher implements Flow.Publisher {
-
-    private final Valve valve;
-    private final ReentrantReadWriteLock.WriteLock pausableFeederNullLock = new ReentrantReadWriteLock().writeLock();
-
-    private volatile Flow.Subscriber singleSubscriber;
-    private volatile PausableFeeder pausableFeeder;
-
-    /**
-     * Creates a {@link java.util.concurrent.Flow.Publisher} wrapping a provided {@link Valve}.
-     * Depending on the Valve implementation, only the first {@link java.util.concurrent.Flow.Subscriber}
-     * (subscribed to any number of such created publishers for a single {@link Valve} instance) that calls
-     * {@link java.util.concurrent.Flow.Subscription#request(long)} will be able to consume the produced items.
-     *
-     * @param valve the valve to wrap
-     */
-    ValvePublisher(Valve valve) {
-        this.valve = valve;
-    }
-
-    @Override
-    public void subscribe(Flow.Subscriber subscriber) {
-
-        synchronized (this) {
-            if (this.singleSubscriber != null) {
-                subscriber.onError(new IllegalStateException("Multiple subscribers aren't allowed!"));
-                return;
-            }
-            this.singleSubscriber = subscriber;
-        }
-
-        this.singleSubscriber.onSubscribe(new Flow.Subscription() {
-            @Override
-            public void request(long n) {
-
-                if (n <= 0) {
-                    subscriber.onError(new IllegalArgumentException("Requested illegal item count: " + 0));
-                    return;
-                }
-
-                if (pausableFeeder != null) {
-                    // a standard release
-                    pausableFeeder.release(n);
-                } else {
-                    try {
-                        pausableFeederNullLock.lock();
-
-                        if (pausableFeeder == null) {
-                            // the first item is always emitted, as such we set one less
-                            pausableFeeder = new PausableFeeder(n - 1, valve);
-
-                            handleValve();
-                        } else {
-                            // pausableFeeder actually is not null, do a standard release
-                            pausableFeeder.release(n);
-                        }
-                    } finally {
-                        pausableFeederNullLock.unlock();
-                    }
-                }
-            }
-
-            @Override
-            public void cancel() {
-                valve.pause();
-            }
-        });
-    }
-
-    private void handleValve() {
-        valve.handle((data) -> {
-                         singleSubscriber.onNext(data);
-                         pausableFeeder.acquire();
-                     },
-                     throwable -> singleSubscriber.onError(new IllegalStateException(
-                             "Valve to Publisher in an error.",
-                             throwable)),
-                     singleSubscriber::onComplete);
-    }
-
-    private static class PausableFeeder {
-        private final Pausable pausable;
-        private final ReentrantReadWriteLock.WriteLock lock = new ReentrantReadWriteLock().writeLock();
-
-        private volatile long count;
-
-        PausableFeeder(long count, Pausable pausable) {
-            this.count = count;
-            this.pausable = pausable;
-        }
-
-        private void acquire() {
-            try {
-                lock.lock();
-
-                count = count == Long.MAX_VALUE
-                        ? count
-                        : count == 0 ? 0 : count - 1;
-
-                if (count == 0) {
-                    pausable.pause();
-                }
-            } finally {
-                lock.unlock();
-            }
-        }
-
-        private void release(long n) {
-            try {
-                lock.lock();
-
-                long r = count + n;
-                // HD 2-12 Overflow iff both arguments have the opposite sign of the result; inspired by Math.addExact(long, long)
-                count = r == Long.MAX_VALUE || ((count ^ r) & (n ^ r)) < 0
-                        // unbounded reached
-                        ? Long.MAX_VALUE
-                        : count + n;
-
-                pausable.resume();
-            } finally {
-                lock.unlock();
-            }
-        }
-    }
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valves.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valves.java
deleted file mode 100644
index b100ee5db36..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/Valves.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.io.InputStream;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Flow;
-
-/**
- * An utility class for {@link Valve} interface.
- */
-public class Valves {
-
-    @SuppressWarnings("rawtypes")
-    private static final Valve EMPTY = new EmptyValve<>();
-
-    private Valves() {}
-
-    /**
-     * Creates a {@link Valve} instance from provided array.
-     * 
    
-     * If {@code t array} parameter is {@code null} then returns an empty {@link Valve}.
-     *
-     * @param t   an array to provide as a {@link Valve}
-     * @param  a type of the array items
-     * @return the new instance
-     */
-    @SafeVarargs
-    @SuppressWarnings("varargs")
-    public static  Valve from(T... t) {
-        if (t == null || t.length == 0) {
-            return empty();
-        }
-        return from(Arrays.asList(t));
-    }
-
-    /**
-     * Creates a {@link Valve} instance from the provided {@link Iterable}.
-     * 
    
-     * If {@code iterable} parameter is {@code null} then returns an empty {@link Valve}.
-     *
-     * @param iterable an iterable to provide as a {@link Valve}
-     * @param       a type of iterable items
-     * @return the new instance
-     */
-    public static  Valve from(Iterable iterable) {
-        if (iterable == null) {
-            return empty();
-        }
-        return new IteratorValve<>(iterable.iterator());
-    }
-
-    /**
-     * Creates a {@link ByteBuffer} based {@link Valve} instance from the provided {@link InputStream}.
-     * Each byte buffer will have the provided capacity.
-     * 
    
-     * Each byte buffer uses a newly allocated memory and as such no pooling is performed.
-     *
-     * @param stream         the input stream to create the {@link Valve} from
-     * @param bufferCapacity the capacity of each buffer of bytes
-     * @return the new instance
-     */
-    public static Valve from(InputStream stream, int bufferCapacity) {
-        return from(stream, bufferCapacity, null);
-    }
-
-    /**
-     * Creates a {@link ByteBuffer} based {@link Valve} instance from the provided {@link InputStream}.
-     * Each byte buffer will have the provided capacity.
-     * 
    
-     * Each byte buffer uses a newly allocated memory and as such no pooling is performed.
-     *
-     * @param stream          the input stream to create the {@link Valve} from
-     * @param bufferCapacity  the capacity of each buffer of bytes
-     * @param executorService the executor service to use for an execution of the {@link InputStream#read()}
-     *                        (and its overloads) operations that are blocking by its nature.
-     * @return the new instance
-     */
-    public static Valve from(InputStream stream, int bufferCapacity, ExecutorService executorService) {
-        if (stream == null) {
-            return empty();
-        }
-        if (executorService != null) {
-            return new InputStreamValve.InputStreamExecutorValve(stream, bufferCapacity, executorService);
-        } else {
-            return new InputStreamValve(stream, bufferCapacity);
-        }
-    }
-
-    /**
-     * Creates a {@link Valve} instance from provided {@link java.util.concurrent.Flow.Publisher}.
-     * 
    
-     * If {@code publisher} parameter is {@code null} then returns an empty {@link Valve}.
-     *
-     * @param publisher a publisher to provide as a {@link Valve}
-     * @param        a type of published items
-     * @return the new instance
-     */
-    public static  Valve from(Flow.Publisher publisher) {
-        if (publisher == null) {
-            return empty();
-        }
-        return new PublisherValve<>(publisher);
-    }
-
-    /**
-     * Returns an empty {@link Valve} - instance, which report complete as soon as handler is registered.
-     * 
    
-     * For performance reason, this particular Valve accepts any amount of handlers.
-     *
-     * @param  type of the item (which is not there :-) )
-     * @return singleton instance
-     */
-    @SuppressWarnings("unchecked")
-    public static  Valve empty() {
-        return (Valve) EMPTY;
-    }
-
-}
diff --git a/common/reactive/src/main/java/io/helidon/common/reactive/valve/package-info.java b/common/reactive/src/main/java/io/helidon/common/reactive/valve/package-info.java
deleted file mode 100644
index fd4f83f1840..00000000000
--- a/common/reactive/src/main/java/io/helidon/common/reactive/valve/package-info.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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.
- */
-
-/**
- * Reactive utilities for Helidon projects.
- *
- * @see io.helidon.common.reactive.valve.Valve
- * @see io.helidon.common.reactive.valve.Valves
- * @see io.helidon.common.reactive.valve.InputStreamValve
- * @see io.helidon.common.reactive.valve.Tank
- */
-package io.helidon.common.reactive.valve;
diff --git a/common/reactive/src/main/java/module-info.java b/common/reactive/src/main/java/module-info.java
index 8d2a50f3126..2f64d9118c8 100644
--- a/common/reactive/src/main/java/module-info.java
+++ b/common/reactive/src/main/java/module-info.java
@@ -25,5 +25,4 @@
     requires io.helidon.common.mapper;
 
     exports io.helidon.common.reactive;
-    exports io.helidon.common.reactive.valve;
 }
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/CloseableSupportTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/CloseableSupportTest.java
deleted file mode 100644
index 8ab51aebd48..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/CloseableSupportTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ForkJoinPool;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-class CloseableSupportTest {
-
-    @Test
-    void singleThread() {
-        CloseableSupport cs = new CloseableSupport();
-        assertThat("Closeable must not be closed by default", cs.closed(), is(false));
-
-        cs.close();
-        assertThat("Closeable must be closed when close is callded", cs.closed(), is(true));
-    }
-
-    @Test
-    void otherThread() throws ExecutionException, InterruptedException {
-        CloseableSupport cs = new CloseableSupport();
-        assertThat("Closeable must not be closed by default", cs.closed(), is(false));
-        ForkJoinPool.commonPool().submit(cs::close).get();
-        assertThat("Closeable must be closed when close is callded", cs.closed(), is(true));
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/InputStreamValveTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/InputStreamValveTest.java
deleted file mode 100644
index 3cfc89f971a..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/InputStreamValveTest.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Function;
-
-import org.hamcrest.Matcher;
-import org.hamcrest.collection.IsCollectionWithSize;
-import org.hamcrest.core.AllOf;
-import org.hamcrest.core.AnyOf;
-import org.hamcrest.core.Every;
-import org.hamcrest.core.Is;
-import org.hamcrest.core.IsCollectionContaining;
-import org.hamcrest.core.StringStartsWith;
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-/**
- * The InputStreamValveTest.
- */
-class InputStreamValveTest {
-
-    private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor(r -> new Thread(r) {{
-        setName("test-thread");
-    }});
-    private static final int LARGE_DATA_YIELDING_SIZE = 10000;
-    private static final int LARGE_DATA_SIZE = 100000;
-
-    @Test
-    void sameThreadAscii() throws Exception {
-        String string = "qwertyuiopasdfghjklzxcvbnm1234567890";
-
-        verifyFromString(string, StandardCharsets.US_ASCII);
-    }
-
-    @Test
-    void sameThreadLargeAscii() throws Exception {
-        String string = "qwertyuiopasdfghjklzxcvbnm1234567890";
-        StringBuilder stringBuilder = new StringBuilder(LARGE_DATA_SIZE * string.length());
-        for (int i = 0; i < LARGE_DATA_SIZE; i++) {
-            stringBuilder.append(string);
-        }
-        verifyFromString(stringBuilder.toString(), StandardCharsets.US_ASCII, null, 8 * 1024, 441, "main");
-    }
-
-    @Test
-    void sameThreadResumedYieldingLargeAscii() throws Exception {
-        verifyOnExecutorService(null);
-    }
-
-    @Test
-    void onExecutorYieldingLargeAscii() throws Exception {
-        AtomicLong counter = new AtomicLong(1);
-        verifyOnExecutorService(Executors.newFixedThreadPool(16,
-                                          r -> new Thread(r::run,
-                                                          "test-thread-" + counter
-                                                                  .getAndIncrement())));
-    }
-
-    private void verifyOnExecutorService(ExecutorService executorService) throws Exception {
-        String string = "qwertyuiopasdfghjklzxcvbnm1234567890";
-        StringBuilder stringBuilder = new StringBuilder(LARGE_DATA_YIELDING_SIZE * string.length());
-        for (int i = 0; i < LARGE_DATA_YIELDING_SIZE; i++) {
-            stringBuilder.append(string);
-        }
-
-        AtomicBoolean completed = new AtomicBoolean(false);
-
-        Function> valveFunction = stream -> {
-            Valve valve;
-            if (executorService != null) {
-                valve = new InputStreamValve
-                        .InputStreamExecutorValve(stream, 1024, executorService) {
-                    @Override
-                    protected ByteBuffer moreData() throws Throwable {
-                        Thread.yield();
-                        return super.moreData();
-                    }
-                };
-            } else {
-                valve = new InputStreamValve(stream, 1024) {
-                    @Override
-                    protected ByteBuffer moreData() throws Throwable {
-                        Thread.yield();
-                        return super.moreData();
-                    }
-                };
-            }
-
-            Executors.newSingleThreadExecutor(r -> new Thread(r, "test-thread-resuming")).submit(() -> {
-                while (!completed.get()) {
-                    valve.pause();
-                    Thread.yield();
-                    valve.resume();
-                    Thread.yield();
-                }
-            });
-
-            return valve;
-        };
-        try {
-            Matcher itemMatcher = StringStartsWith.startsWith("test-thread-");
-            if (executorService == null) {
-                itemMatcher = AnyOf.anyOf(itemMatcher, Is.is("main"));
-            }
-            verifyFromString(stringBuilder.toString(), StandardCharsets.US_ASCII, 353,
-                             valveFunction, Every.everyItem(itemMatcher));
-        } finally {
-            completed.set(true);
-        }
-    }
-
-    @Test
-    void onExecutorAscii() throws Exception {
-        String string = "qwertyuiopasdfghjklzxcvbnm1234567890";
-
-        verifyFromString(string, StandardCharsets.US_ASCII, EXECUTOR_SERVICE, 64, 2, "test-thread");
-    }
-
-    @Test
-    void sameThreadUTF_8() throws Exception {
-        String string = "asdf+ěščŘŽÝÁ";
-
-        verifyFromString(string, StandardCharsets.UTF_8);
-    }
-
-    private void verifyFromString(String string,
-                                  Charset charset,
-                                  ExecutorService executorService,
-                                  int bufferSize,
-                                  int expectedCallCount,
-                                  String... threadNames) throws Exception {
-        verifyFromString(string,
-                         charset,
-                         expectedCallCount,
-                         stream -> Valves.from(stream, bufferSize, executorService),
-                         threadNames);
-    }
-
-    private void verifyFromString(String string, final Charset charset) throws Exception {
-        verifyFromString(string, charset, 2, stream -> Valves.from(stream, 64, null), "main");
-    }
-
-    @SuppressWarnings("unchecked")
-    private void verifyFromString(String string,
-                                  final Charset charset,
-                                  int expected,
-                                  Function> valveFunction,
-                                  String... items) throws Exception {
-        verifyFromString(string, charset, expected, valveFunction,
-                         AllOf.allOf((Matcher) IsCollectionWithSize.hasSize(items.length),
-                                     IsCollectionContaining.hasItems(items)));
-    }
-
-    @SuppressWarnings("unchecked")
-    private void verifyFromString(String string,
-                                  final Charset charset,
-                                  int expected,
-                                  Function> valveFunction,
-                                  Matcher matcher) throws Exception {
-        AtomicLong readCounter = new AtomicLong();
-        Set threadNames = new HashSet<>();
-
-        ByteArrayInputStream stream = new ByteArrayInputStream(string.getBytes(charset)) {
-            @Override
-            public int read(byte[] b) throws IOException {
-                readCounter.incrementAndGet();
-                threadNames.add(Thread.currentThread().getName());
-
-                return super.read(b);
-            }
-        };
-
-        Valve valve = valveFunction.apply(stream);
-
-        String result = valve.collect(InputStreamValve.byteBufferStringCollector(charset))
-                             .toCompletableFuture()
-                             .get();
-
-        assertThat(result, is(string));
-        assertThat(readCounter.intValue(), is(expected));
-
-        assertThat("Unexpected thread names: " + threadNames, threadNames, matcher);
-    }
-
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/IteratorValveTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/IteratorValveTest.java
deleted file mode 100644
index 860298df050..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/IteratorValveTest.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-/**
- * Tests {@link IteratorValve}.
- */
-public class IteratorValveTest {
-
-    private static final String ALPHABET = "abcdeghijklmnopqrstuvwxyz";
-
-    private Collection toCollection(String str) {
-        Collection result = new ArrayList<>(str.length());
-        for (int i = 0; i < str.length(); i++) {
-            result.add(str.charAt(i));
-        }
-        return result;
-    }
-
-    @Test
-    public void nonStop() throws Exception {
-        IteratorValve valve = new IteratorValve<>(toCollection(ALPHABET).iterator());
-        AssertableStringBuilder asb = new AssertableStringBuilder();
-        valve.handle(asb::append, asb::onError, asb::onDone);
-        asb.awaitAndAssert(ALPHABET);
-    }
-
-    @Test
-    public void pauseAndResumeInside() throws Exception {
-        IteratorValve valve = new IteratorValve<>(toCollection(ALPHABET).iterator());
-        AssertableStringBuilder asb = new AssertableStringBuilder();
-        CountDownLatch halfLatch = new CountDownLatch(1);
-        valve.handle(ch -> {
-            if (ch.equals('m')) {
-                valve.pause();
-                halfLatch.countDown();
-            }
-            asb.append(ch);
-        }, asb::onError, asb::onDone);
-        if (!halfLatch.await(5, TimeUnit.SECONDS)) {
-            throw new AssertionError("Timeout");
-        }
-        valve.resume();
-        asb.awaitAndAssert(ALPHABET);
-    }
-
-    void neco() {
-        boolean sex = Math.random() > 0.5;
-        boolean java = Math.random() > 0.5;
-        boolean rock = Math.random() > 0.5;
-        boolean roll = Math.random() > 0.5;
-
-        if (sex && java && (rock & roll)) {
-            System.out.println("vole");
-        }
-    }
-
-    @Test
-    public void pauseExternalResume() throws Exception {
-        IteratorValve valve = new IteratorValve<>(toCollection(ALPHABET).iterator());
-        AssertableStringBuilder asb = new AssertableStringBuilder();
-        valve.handle(ch -> {
-            valve.pause();
-            asb.append(ch);
-            valve.resume();
-        }, asb::onError, asb::onDone);
-        asb.awaitAndAssert(ALPHABET);
-    }
-
-    static class AssertableStringBuilder extends Finisher {
-
-        StringBuilder stringBuilder = new StringBuilder();
-
-        void append(Character ch) {
-            stringBuilder.append(ch);
-        }
-
-        void awaitAndAssert(String expected) throws Exception{
-            await();
-            assertThat(stringBuilder.toString(), is(expected));
-        }
-    }
-
-    static class Finisher {
-
-        private CountDownLatch latch = new CountDownLatch(1);
-        private volatile Throwable throwable;
-
-        void onError(Throwable thr) {
-            throwable = thr;
-            onDone();
-        }
-
-        void onDone() {
-            latch.countDown();
-        }
-
-        void await() throws Exception {
-            if (!latch.await(5, TimeUnit.SECONDS)) {
-                throw new AssertionError("Timeout");
-            }
-            if (throwable != null) {
-                if (throwable instanceof Exception) {
-                    throw (Exception) throwable;
-                } else {
-                    throw new AssertionError("Execution issue", throwable);
-                }
-            }
-        }
-
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/PausableRegistryTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/PausableRegistryTest.java
deleted file mode 100644
index 24b4cc6f81f..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/PausableRegistryTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.io.IOException;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-class PausableRegistryTest {
-
-    @Test
-    void doubleHandlers() {
-        CountingRegistry reg = new CountingRegistry<>();
-        reg.handle((data, psb) -> {}, null, null);
-        assertThrows(IllegalStateException.class, () -> reg.handle((data, psb) -> {
-        }, null, null));
-    }
-
-    @Test
-    void resumeCallsTryProcess() {
-        CountingRegistry reg = new CountingRegistry();
-        reg.resume();
-        assertThat(reg.counter.get(), is(1));
-        reg.resume();
-        assertThat(reg.counter.get(), is(2));
-    }
-
-    @Test
-    void noProcessIfNoHandler() {
-        CountingRegistry reg = new CountingRegistry<>();
-        assertThat(reg.canProcess(), is(false));
-        reg.resume();
-        assertThat(reg.canProcess(), is(false));
-        reg.handle((data, psb) -> {}, null, null);
-        assertThat(reg.canProcess(), is(true));
-        assertThat(reg.paused(), is(false));
-        assertThat(reg.canContinueProcessing(), is(true));
-    }
-
-    @Test
-    void processByHandlerRegistration() {
-        CountingRegistry reg = new CountingRegistry<>();
-        assertThat(reg.counter.get(), is(0));
-        reg.handle((data, psb) -> {}, null, null);
-        assertThat(reg.counter.get(), is(1));
-    }
-
-    @Test
-    void pauseResume() {
-        CountingRegistry reg = new CountingRegistry<>();
-        reg.handle((data, psb) -> {}, null, null);
-        assertThat(reg.canProcess(), is(true));
-        assertThat(reg.paused(), is(false));
-        assertThat(reg.canContinueProcessing(), is(true));
-        reg.pause();
-        assertThat(reg.canContinueProcessing(), is(false));
-        assertThat(reg.paused(), is(true));
-        assertThat(reg.canProcess(), is(false));
-        reg.resume();
-        assertThat(reg.canProcess(), is(true));
-        assertThat(reg.paused(), is(false));
-        assertThat(reg.canContinueProcessing(), is(true));
-    }
-
-    @Test
-    void notTwoProcessors() {
-        CountingRegistry reg = new CountingRegistry<>();
-        reg.handle((data, psb) -> {}, null, null);
-        assertThat(reg.canProcess(), is(true));
-        assertThat(reg.canProcess(), is(false));
-        reg.releaseProcessing();
-        assertThat(reg.canProcess(), is(true));
-    }
-
-    @Test
-    void reportError() {
-        AtomicReference ref = new AtomicReference<>();
-        CountingRegistry reg = new CountingRegistry<>();
-        reg.handle((data, psb) -> {}, ref::set, null);
-        reg.handleError(new IOException());
-        assertThat(ref.get(), notNullValue());
-        assertThat(ref.get(), instanceOf(IOException.class));
-    }
-
-    @Test
-    void reportErrorIfNoRegisteredErrorHandler() {
-        CountingRegistry reg = new CountingRegistry<>();
-        reg.handle((data, psb) -> {}, null, null);
-        reg.handleError(new Exception("Just for test!"));
-    }
-
-    static class CountingRegistry extends PausableRegistry {
-
-        private final AtomicInteger counter = new AtomicInteger(0);
-
-        @Override
-        protected void tryProcess() {
-            counter.incrementAndGet();
-        }
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/PublisherValveTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/PublisherValveTest.java
deleted file mode 100644
index 162b864e085..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/PublisherValveTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import io.helidon.common.reactive.SubmissionPublisher;
-
-import org.junit.jupiter.api.Test;
-
-import static io.helidon.common.reactive.valve.TestUtils.generate;
-import static io.helidon.common.reactive.valve.TestUtils.generateList;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-class PublisherValveTest {
-
-    @Test
-    void publish() throws Exception {
-        SubmissionPublisher pub = new SubmissionPublisher<>();
-        PublisherValve valve = new PublisherValve<>(pub);
-        CompletableFuture> cf = valve.collect(Collectors.toList()).toCompletableFuture();
-        generate(0, 10, pub::submit);
-        pub.close();
-        assertThat(cf.get(), is(generateList(0, 10)));
-    }
-
-    @Test
-    void twoHandlers() {
-        List buffer = Collections.synchronizedList(new ArrayList<>(10));
-        SubmissionPublisher pub = new SubmissionPublisher<>();
-        PublisherValve valve = new PublisherValve<>(pub);
-        valve.handle((Consumer) buffer::add);
-        assertThrows(IllegalStateException.class, () -> valve.handle((Consumer) buffer::add));
-    }
-
-    @Test
-    void pauseResume() throws Exception {
-        List buffer = Collections.synchronizedList(new ArrayList<>(10));
-        CountDownLatch latch = new CountDownLatch(1);
-        CountDownLatch doneLatch = new CountDownLatch(1);
-        SubmissionPublisher pub = new SubmissionPublisher<>();
-        Valve valve = Valves.from(pub);
-        valve.handle((i, p) -> {
-            buffer.add(i);
-            if (i == 5) {
-                p.pause();
-                latch.countDown();
-            }
-        }, null, doneLatch::countDown);
-        generate(0, 10, pub::submit);
-        pub.close();
-        if (!latch.await(10, TimeUnit.SECONDS)) {
-            throw new AssertionError("Wait timeout!");
-        }
-        assertThat(buffer, is(generateList(0, 6)));
-        assertThat(doneLatch.getCount(), is(1L));
-        valve.resume();
-        if (!doneLatch.await(10, TimeUnit.SECONDS)) {
-            throw new AssertionError("Wait timeout!");
-        }
-        assertThat(buffer, is(generateList(0, 10)));
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/TankTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/TankTest.java
deleted file mode 100644
index 21ed4d135b7..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/TankTest.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.ForkJoinTask;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-import org.junit.jupiter.api.Test;
-
-import static io.helidon.common.reactive.valve.TestUtils.generate;
-import static io.helidon.common.reactive.valve.TestUtils.generateList;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-class TankTest {
-
-    @Test
-    void readPrefilled() throws Exception {
-        Tank tank = new Tank<>(100);
-        generate(0, 30, tank::add);
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        assertThat(cf.isDone(), is(false));
-
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 30)));
-    }
-
-    @Test
-    void diferentTypeOfInsert() throws Exception {
-        Tank tank = new Tank<>(30);
-        generate(0, 30, tank::add);
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        tank.add(30);
-        assertThat(tank.offer(31), is(true));
-        tank.put(32);
-        tank.addAll(generateList(33, 40));
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 40)));
-    }
-
-    @Test
-    void pauseResume1() throws Exception {
-        Tank tank = new Tank<>(300);
-        generate(0, 30, tank::add);
-        CompletableFuture> cf = tank.filter(i -> {
-            if (i == 10) {
-                tank.pause();
-            }
-            return true;
-        })
-                                                  .collect(Collectors.toList())
-                                                  .toCompletableFuture();
-        generate(30, 40, tank::add);
-        tank.resume();
-        generate(40, 50, tank::add);
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 50)));
-    }
-
-    @Test
-    void pauseResume2() throws Exception {
-        Tank tank = new Tank<>(300);
-        CompletableFuture> cf = tank.filter(i -> {
-            if (i == 5) {
-                tank.pause();
-            }
-            return true;
-        })
-                                                  .collect(Collectors.toList())
-                                                  .toCompletableFuture();
-        generate(0, 10, tank::add);
-        tank.resume();
-        generate(10, 20, tank::add);
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 20)));
-    }
-
-    @Test
-    void offerToFull() throws Exception {
-        Tank tank = new Tank<>(10);
-        generate(0, 10, tank::add);
-        assertThat(tank.offer(10), is(false));
-        ForkJoinTask f = ForkJoinPool.commonPool()
-                                              .submit(() -> tank.offer(10, 10, TimeUnit.SECONDS));
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        assertThat(f.get(), is(true));
-        assertThat(tank.offer(11), is(true));
-
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 12)));
-    }
-
-    @Test
-    void noInsertAfterClose() throws Exception {
-        Tank tank = new Tank<>(100);
-        generate(0, 10, tank::add);
-        tank.close();
-        assertThat(tank.offer(10), is(false));
-        assertThrows(IllegalStateException.class, () -> tank.add(11));
-        assertThrows(IllegalStateException.class, () -> tank.put(12));
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        assertThat(cf.get(), is(generateList(0, 10)));
-    }
-
-    @Test
-    void insertFromDrainHandler() throws Exception {
-        Tank tank = new Tank<>(100);
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        tank.whenDrain(() -> generate(0, 10, tank::add));
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 10)));
-    }
-
-    @Test
-    void insertFromDrainHandlerToFull() throws Exception {
-        Tank tank = new Tank<>(10);
-        generate(0, 10, tank::add);
-        tank.whenDrain(() -> generate(10, 15, tank::add));
-        CompletableFuture> cf = tank.collect(Collectors.toList()).toCompletableFuture();
-        tank.close();
-        assertThat(cf.get(), is(generateList(0, 15)));
-    }
-
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/TestUtils.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/TestUtils.java
deleted file mode 100644
index 0090ba5e268..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/TestUtils.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-
-class TestUtils {
-
-    static void generate(int from, int to, Consumer consumer) {
-        for (int i = from; i < to; i++) {
-            consumer.accept(i);
-        }
-    }
-
-    static List generateList(int from, int to) {
-        ArrayList result = new ArrayList<>(to - from);
-        for (int i = from; i < to; i++) {
-            result.add(i);
-        }
-        return result;
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/UnorderedCollectorSupportTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/UnorderedCollectorSupportTest.java
deleted file mode 100644
index 2ad25658afa..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/UnorderedCollectorSupportTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-/**
- * Tests {@link UnorderedCollectorSupport}.
- */
-class UnorderedCollectorSupportTest {
-
-    private void fillAndTest(int threadsCount, int valuesPerThread) throws Exception {
-        UnorderedCollectorSupport> support = new UnorderedCollectorSupport<>(Collectors.toSet());
-        CountDownLatch latch = new CountDownLatch(threadsCount);
-        for (int i = 0; i < threadsCount; i++) {
-            int base = i * valuesPerThread;
-            new Thread(() -> {
-                for (int j = 0; j < valuesPerThread; j++) {
-                    support.add(base + j);
-                }
-                latch.countDown();
-            }).start();
-        }
-        if (!latch.await(1, TimeUnit.MINUTES)) {
-            throw new AssertionError("Timeout!");
-        }
-        support.complete();
-        Set result = support.getResult()
-                                       .toCompletableFuture()
-                                       .get(10, TimeUnit.SECONDS);
-        assertThat(result.size(), is(threadsCount * valuesPerThread));
-    }
-
-    @Test
-    void singleThread() throws Exception {
-        fillAndTest(1, 100_000);
-    }
-
-    @Test
-    void eightThreads() throws Exception {
-        fillAndTest(8, 400_000);
-    }
-
-    @Test
-    void threeHundredsThreads() throws Exception {
-        fillAndTest(300, 20_000);
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveIteratorTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveIteratorTest.java
deleted file mode 100644
index 0078d0552ba..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveIteratorTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.NoSuchElementException;
-import java.util.concurrent.ForkJoinPool;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-class ValveIteratorTest {
-
-    @Test
-    void standard() {
-        Valve valve = Valves.from(ValveTest.LIST_0_100);
-        assertToIterator(ValveTest.LIST_0_100, valve);
-    }
-
-    @Test
-    void async() {
-        Valve valve = Valves.from(ValveTest.LIST_0_10).executeOn(ForkJoinPool.commonPool());
-        assertToIterator(ValveTest.LIST_0_10, valve);
-    }
-
-    @Test
-    void failing() {
-        Valve valve = Valves.from(ValveTest.LIST_0_10)
-                .peek(i -> {
-                    if (i == 5) {
-                        throw new IllegalStateException("Test exception");
-                    }
-                });
-        ValveIterator iterator = valve.toIterator();
-        int lastValue = -1;
-        while (iterator.hasNext()) {
-            lastValue = iterator.next();
-        }
-        assertThat(lastValue, is(4));
-
-        assertThat(iterator.getThrowable(), notNullValue());
-        assertThat(iterator.getThrowable().getMessage(), is("Test exception"));
-    }
-
-    @Test
-    void multipleHasNext() {
-        ValveIterator iterator = Valves.from(ValveTest.LIST_0_5).toIterator();
-        while (iterator.hasNext()) {
-            iterator.next();
-        }
-        assertThat(iterator.hasNext(), is(false));
-        assertThat(iterator.hasNext(), is(false));
-    }
-
-    @Test
-    void nextAfterFinished() {
-        ValveIterator iterator = Valves.from(ValveTest.LIST_0_5).toIterator();
-        while (iterator.hasNext()) {
-            iterator.next();
-        }
-        assertThrows(NoSuchElementException.class, iterator::next);
-    }
-
-    private  void assertToIterator(Collection data, Valve valve) {
-        Collection result = new ArrayList<>(data.size());
-        for (C item : toIterable(valve)) {
-            result.add(item);
-        }
-        assertThat(result, is(data));
-    }
-
-    private static  Iterable toIterable(Valve valve) {
-        return valve::toIterator;
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvePublisherTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvePublisherTest.java
deleted file mode 100644
index 7e534dda711..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvePublisherTest.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Flow.Subscriber;
-import java.util.concurrent.Flow.Subscription;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import io.helidon.common.reactive.Collector;
-import io.helidon.common.reactive.Multi;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.hasItems;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
-/**
- * The ValvePublisherTest.
- */
-class ValvePublisherTest {
-
-    @Test
-    void simpleTest() throws Exception {
-        List list = Multi.from(Valves.from(1, 2, 3, 4).toPublisher())
-                .collectList()
-                .get(10, TimeUnit.SECONDS);
-
-        assertThat(list, hasItems(1, 2, 3, 4));
-    }
-
-    @Test
-    void continuous() {
-        StringBuilder sb = new StringBuilder();
-        Tank integerTank = new Tank<>(10);
-
-        Multi.from(integerTank.toPublisher())
-                .subscribe(sb::append);
-
-        integerTank.add(1);
-        integerTank.add(2);
-        assertThat(sb.toString(), is("12"));
-
-        integerTank.add(3);
-        integerTank.add(4);
-        assertThat(sb.toString(), is("1234"));
-    }
-
-    @Test
-    void publisher() {
-        final StringBuilder sb = new StringBuilder();
-        Tank integerTank = new Tank<>(10);
-
-        final AtomicReference subscriptionRef = new AtomicReference<>();
-
-        integerTank.toPublisher().subscribe(new Subscriber() {
-            @Override
-            public void onSubscribe(Subscription subscription) {
-                subscriptionRef.set(subscription);
-            }
-
-            @Override
-            public void onNext(Integer item) {
-                sb.append(item);
-            }
-
-            @Override
-            public void onError(Throwable throwable) {
-                fail("Not expected: " + throwable);
-            }
-
-            @Override
-            public void onComplete() {
-                sb.append("$");
-            }
-        });
-
-        integerTank.add(1);
-        integerTank.add(2);
-
-        assertThat(sb.toString(), is(""));
-
-        subscriptionRef.get().request(1);
-        assertThat(sb.toString(), is("1"));
-
-        subscriptionRef.get().request(2);
-        integerTank.add(3);
-        integerTank.add(4);
-        assertThat(sb.toString(), is("123"));
-
-        integerTank.add(5);
-        assertThat(sb.toString(), is("123"));
-        subscriptionRef.get().request(2);
-        assertThat(sb.toString(), is("12345"));
-
-        // request additional 2 more ahead
-        subscriptionRef.get().request(2);
-        assertThat(sb.toString(), is("12345"));
-        integerTank.add(6);
-        assertThat(sb.toString(), is("123456"));
-        integerTank.add(7);
-        assertThat(sb.toString(), is("1234567"));
-
-        // TODO webserver#22 close itself doesn't complete the subscriber; change the test once the issue is solved
-        integerTank.close();
-        assertThat(sb.toString(), is("1234567"));
-        subscriptionRef.get().request(1);
-        assertThat(sb.toString(), is("1234567$"));
-    }
-
-    @Test
-    void onNextThrowsException() {
-        final AtomicReference exception = new AtomicReference<>();
-        Tank integerTank = new Tank<>(10);
-
-        final AtomicReference subscriptionRef = new AtomicReference<>();
-
-        integerTank.toPublisher().subscribe(new Subscriber() {
-            @Override
-            public void onSubscribe(Subscription subscription) {
-                subscriptionRef.set(subscription);
-            }
-
-            @Override
-            public void onNext(Integer item) {
-                throw new RuntimeException("Exception in onNext()");
-            }
-
-            @Override
-            public void onError(Throwable throwable) {
-                exception.set(throwable);
-            }
-
-            @Override
-            public void onComplete() {
-                fail("onComplete not expected");
-            }
-        });
-
-        integerTank.add(1);
-        subscriptionRef.get().request(1);
-
-        assertThat(exception.get().getMessage(), containsString("Valve to Publisher in an error"));
-    }
-
-    @Test
-    void multipleSubscribers() throws Exception {
-        Tank stringTank = new Tank<>(10);
-
-        stringTank.addAll(List.of("1", "2", "3"));
-        stringTank.close();
-
-        Multi multi = Multi.from(stringTank.toPublisher());
-        assertThat(multi.collect(new StringCollector<>()).get(10, TimeUnit.SECONDS), is("123"));
-
-        try {
-            multi.collect(new StringCollector<>()).get(10, TimeUnit.SECONDS);
-            fail("Should have thrown an exception!");
-        } catch (ExecutionException e) {
-            assertThat(e.getCause(), is(notNullValue()));
-            assertThat(e.getCause(), is(instanceOf(IllegalStateException.class)));
-            assertThat(e.getCause().getMessage(), containsString("Multiple subscribers aren't allowed"));
-        }
-    }
-
-    @Test
-    void multiplePublishers() throws Exception {
-        Tank stringTank = new Tank<>(10);
-
-        stringTank.addAll(List.of("1", "2", "3"));
-        stringTank.close();
-
-        assertThat(Multi.from(stringTank.toPublisher()).collect(new StringCollector<>()).get(10, TimeUnit.SECONDS), is("123"));
-
-        try {
-            Multi.from(stringTank.toPublisher()).collect(new StringCollector<>()).get(10, TimeUnit.SECONDS);
-            fail("Should have thrown an exception!");
-        } catch (ExecutionException e) {
-            assertThat(e.getCause(), is(notNullValue()));
-            assertThat(e.getCause(), is(instanceOf(IllegalStateException.class)));
-            assertThat(e.getCause().getMessage(), containsString("Handler is already registered"));
-        }
-    }
-
-    private static final class StringCollector implements Collector {
-
-        private final StringBuilder sb;
-
-        StringCollector() {
-            this.sb = new StringBuilder();
-        }
-
-        @Override
-        public String value() {
-            return sb.toString();
-        }
-
-        @Override
-        public void collect(T item) {
-            sb.append(item.toString());
-        }
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveTest.java
deleted file mode 100644
index 27ba1d47b5c..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValveTest.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.greaterThan;
-
-class ValveTest {
-
-    static final List LIST_0_100 = new ArrayList<>(100);
-    static final List LIST_0_10 = new ArrayList<>(10);
-    static final List LIST_0_5 = new ArrayList<>(5);
-    static {
-        for (int i = 0; i < 100; i++) {
-            LIST_0_100.add(i);
-        }
-        for (int i = 0; i < 10; i++) {
-            LIST_0_10.add(i);
-        }
-        for (int i = 0; i < 5; i++) {
-            LIST_0_5.add(i);
-        }
-    }
-
-    @Test
-    void testHandle() {
-        List buffer = Collections.synchronizedList(new ArrayList<>(10));
-        AtomicReference thrRef = new AtomicReference<>();
-        AtomicReference resultRef = new AtomicReference<>(false);
-        // --- Basic consumer
-        // Simple
-        Valves.from(LIST_0_10).handle((Consumer) buffer::add);
-        assertThat(buffer, is(LIST_0_10));
-        buffer.clear();
-        // Two Params
-        Valves.from(LIST_0_10).handle((Consumer) buffer::add, thrRef::set);
-        assertThat(buffer, is(LIST_0_10));
-        assertThat(thrRef.get(), nullValue());
-        buffer.clear();
-        // Three Params
-        Valves.from(LIST_0_10).handle((Consumer) buffer::add, thrRef::set, () -> resultRef.set(true));
-        assertThat(buffer, is(LIST_0_10));
-        assertThat(thrRef.get(), nullValue());
-        assertThat(resultRef.get(), is(true));
-        buffer.clear();
-        resultRef.set(false);
-
-        // --- Pausable consumer
-        // Simple
-        Valve valve = Valves.from(LIST_0_10);
-        valve.handle((i, p) -> {
-            if (i == 4) {
-                p.pause();
-            }
-            buffer.add(i);
-        });
-        assertThat(buffer, is(LIST_0_5));
-        valve.resume();
-        assertThat(buffer, is(LIST_0_10));
-        buffer.clear();
-        // Two Params
-        valve = Valves.from(LIST_0_10);
-        valve.handle((i, p) -> {
-            if (i == 4) {
-                p.pause();
-            }
-            buffer.add(i);
-        }, thrRef::set);
-        assertThat(buffer, is(LIST_0_5));
-        valve.resume();
-        assertThat(buffer, is(LIST_0_10));
-        assertThat(thrRef.get(), nullValue());
-        buffer.clear();
-        // Three Params
-        valve = Valves.from(LIST_0_10);
-        valve.handle((i, p) -> {
-            if (i == 4) {
-                p.pause();
-            }
-            buffer.add(i);
-        }, thrRef::set, () -> resultRef.set(true));
-        assertThat(buffer, is(LIST_0_5));
-        valve.resume();
-        assertThat(buffer, is(LIST_0_10));
-        assertThat(thrRef.get(), nullValue());
-        assertThat(resultRef.get(), is(true));
-        buffer.clear();
-        resultRef.set(false);
-    }
-
-    @Test
-    void filter() throws Exception {
-        List result = Valves.from(LIST_0_10)
-                                     .filter(i -> i < 5)
-                                     .collect(Collectors.toList())
-                                     .toCompletableFuture()
-                                     .get();
-
-        assertThat(result, is(LIST_0_5));
-    }
-
-    @Test
-    void map() throws Exception {
-        String result = Valves.from(LIST_0_10)
-                              .map(String::valueOf)
-                              .collect(Collectors.joining())
-                              .toCompletableFuture()
-                              .get();
-
-        String expected = LIST_0_10.stream()
-                .map(String::valueOf)
-                .collect(Collectors.joining());
-
-        assertThat(result, is(expected));
-    }
-
-    @Test
-    void peek() throws Exception {
-        List buffer = Collections.synchronizedList(new ArrayList<>(10));
-        List result = Valves.from(LIST_0_10)
-                                     .peek(buffer::add)
-                                     .collect(Collectors.toList())
-                                     .toCompletableFuture()
-                                     .get();
-        assertThat(buffer, is(LIST_0_10));
-        assertThat(result, is(LIST_0_10));
-    }
-
-    @Test
-    void onExecutorService() throws Exception {
-        Set threadNames = Collections.synchronizedSet(new TreeSet<>());
-        threadNames.add(Thread.currentThread().getName());
-        List result = Valves.from(LIST_0_100)
-                                     .executeOn(ForkJoinPool.commonPool())
-                                     .peek(i -> threadNames.add(Thread.currentThread().getName()))
-                                     .collect(Collectors.toList())
-                                     .toCompletableFuture()
-                                     .get();
-
-        assertThat(result, is(LIST_0_100));
-        assertThat(threadNames.size(), greaterThan(1));
-    }
-}
diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvesTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvesTest.java
deleted file mode 100644
index 437407283a9..00000000000
--- a/common/reactive/src/test/java/io/helidon/common/reactive/valve/ValvesTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
- *
- * 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 io.helidon.common.reactive.valve;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.junit.jupiter.api.Test;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-class ValvesTest {
-
-    @Test
-    void fromIterable() throws Exception {
-        List list = List.of("a", "b", "c", "d", "e", "f", "g");
-        String s = Valves.from(list).collect(Collectors.joining()).toCompletableFuture().get();
-        assertThat(s, is("abcdefg"));
-    }
-
-    @Test
-    void fromNullIterable() throws Exception {
-        String s = Valves.from((Iterable) null).collect(Collectors.joining()).toCompletableFuture().get();
-        assertThat(s, is(""));
-    }
-
-    @Test
-    void fromArray() throws Exception {
-        String[] array = {"a", "b", "c", "d", "e", "f", "g"};
-        String s = Valves.from(array).collect(Collectors.joining()).toCompletableFuture().get();
-        assertThat(s, is("abcdefg"));
-    }
-
-    @Test
-    void fromNullArray() throws Exception {
-        String[] array = null;
-        String s = Valves.from(array).collect(Collectors.joining()).toCompletableFuture().get();
-        assertThat(s, is(""));
-    }
-
-    @Test
-    void empty() throws Exception {
-        Valve valve = Valves.empty();
-        String s = valve.collect(Collectors.joining()).toCompletableFuture().get();
-        assertThat(s, is(""));
-    }
-}

From e31d54b5f6d625fc048d05ea2773e56039a32240 Mon Sep 17 00:00:00 2001
From: Daniel Kec 
Date: Wed, 8 Jan 2020 11:35:10 +0100
Subject: [PATCH 65/66] HttpRequestScopedPublisher doesn't close connection

Signed-off-by: Daniel Kec 
---
 .../common/reactive/BaseProcessorTest.java       | 16 ----------------
 .../webserver/HttpRequestScopedPublisher.java    |  5 -----
 2 files changed, 21 deletions(-)

diff --git a/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java b/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
index b10557a3a09..86e06567607 100644
--- a/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
+++ b/common/reactive/src/test/java/io/helidon/common/reactive/BaseProcessorTest.java
@@ -237,22 +237,6 @@ public void testDoubleSubscribe() {
         assertThat(subscriber2.getSubcription(), is(nullValue()));
     }
 
-    @Test
-    @Disabled("Against https://github.com/reactive-streams/reactive-streams-jvm#2.5")
-    public void testSubscriptionNotCanceled() {
-        TestProcessor processor = new TestProcessor<>();
-        TestSubscription subscription = new TestSubscription();
-        processor.onSubscribe(subscription);
-        TestSubscriber subscriber = new TestSubscriber() {
-            @Override
-            public void onSubscribe(Subscription subscription) {
-                subscription.cancel();
-            }
-        };
-        processor.subscribe(subscriber);
-        assertThat(subscription.canceled, is(equalTo(false)));
-    }
-
     @Test
     public void testNotEnoughRequestToSubmit() {
         TestProcessor processor = new TestProcessor<>();
diff --git a/webserver/webserver/src/main/java/io/helidon/webserver/HttpRequestScopedPublisher.java b/webserver/webserver/src/main/java/io/helidon/webserver/HttpRequestScopedPublisher.java
index 5c41a9565d0..128ad07f9dd 100644
--- a/webserver/webserver/src/main/java/io/helidon/webserver/HttpRequestScopedPublisher.java
+++ b/webserver/webserver/src/main/java/io/helidon/webserver/HttpRequestScopedPublisher.java
@@ -44,11 +44,6 @@ class HttpRequestScopedPublisher extends OriginThreadPublisher
Date: Wed, 8 Jan 2020 11:50:41 +0100
Subject: [PATCH 66/66] Copyright fix for happy new year 2020!

Signed-off-by: Daniel Kec 
---
 common/reactive/pom.xml                                         | 2 +-
 common/reactive/src/main/java/module-info.java                  | 2 +-
 .../test/java/io/helidon/common/reactive/BaseProcessorTest.java | 2 +-
 .../java/io/helidon/webserver/HttpRequestScopedPublisher.java   | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/common/reactive/pom.xml b/common/reactive/pom.xml
index 9a000ab61a5..cb8a670692c 100644
--- a/common/reactive/pom.xml
+++ b/common/reactive/pom.xml
@@ -1,7 +1,7 @@