org.apache.pulsar.client.api.ConsumerBuilder Java Examples

public static void main(String[] args) throws PulsarClientException {
    PulsarClient client = PulsarClient.builder()
            .serviceUrl(SERVICE_URL)
            .build();

    Producer<byte[]> producer = client.newProducer()
            .topic(TOPIC_NAME)
            .create();

    ConsumerBuilder<byte[]> consumer1 = client.newConsumer()
            .topic(TOPIC_NAME)
            .subscriptionName(SUBSCRIPTION_NAME)
            .subscriptionType(SUBSCRIPTION_TYPE);

    ConsumerBuilder<byte[]> consumer2 = client.newConsumer()
            .topic(TOPIC_NAME)
            .subscriptionName(SUBSCRIPTION_NAME)
            .subscriptionType(SUBSCRIPTION_TYPE);

    IntStream.range(0, 999).forEach(i -> {
        Message<byte[]> msg = MessageBuilder.create()
                .setContent(String.format("message-%d", i).getBytes())
                .build();
        try {
            producer.send(msg);
        } catch (PulsarClientException e) {
            System.out.println(e.getMessage());
        }
    });

    // Consumer 1 can subscribe to the topic
    consumer1.subscribe();

    // Consumer 2 cannot due to the exclusive subscription held by consumer 1
    consumer2.subscribeAsync()
            .handle((consumer, exception) -> {
                System.out.println(exception.getMessage());
                return null;
            });
}
 

@Override
public ConsumerBuilder<T> ackTimeoutTickTime(long tickTime, TimeUnit timeUnit) {
    checkArgument(timeUnit.toMillis(tickTime) >= MIN_TICK_TIME_MILLIS,
            "Ack timeout tick time should be greater than " + MIN_TICK_TIME_MILLIS + " ms");
    conf.setTickDurationMillis(timeUnit.toMillis(tickTime));
    return this;
}
 

@Override
public ConsumerBuilder<T> topics(List<String> topicNames) {
    checkArgument(topicNames != null && !topicNames.isEmpty(),
            "Passed in topicNames list should not be null or empty.");
    topicNames.stream().forEach(topicName ->
            checkArgument(StringUtils.isNotBlank(topicName), "topicNames cannot have blank topic"));
    conf.getTopicNames().addAll(topicNames.stream().map(StringUtils::trim).collect(Collectors.toList()));
    return this;
}
 

@Override
public ConsumerBuilder<T> topic(String... topicNames) {
    checkArgument(topicNames != null && topicNames.length > 0,
            "Passed in topicNames should not be null or empty.");
    Arrays.stream(topicNames).forEach(topicName ->
            checkArgument(StringUtils.isNotBlank(topicName), "topicNames cannot have blank topic"));
    conf.getTopicNames().addAll(Lists.newArrayList(Arrays.stream(topicNames).map(StringUtils::trim)
            .collect(Collectors.toList())));
    return this;
}
 

public static void main(String[] args) throws PulsarClientException {
    PulsarClient client = PulsarClient.builder()
            .serviceUrl(SERVICE_URL)
            .build();

    Producer<byte[]> producer = client.newProducer()
            .topic(TOPIC_NAME)
            .create();

    ConsumerBuilder<byte[]> consumer1 = client.newConsumer()
            .topic(TOPIC_NAME)
            .subscriptionName(SUBSCRIPTION_NAME)
            .subscriptionType(SUBSCRIPTION_TYPE);

    ConsumerBuilder<byte[]> consumer2 = client.newConsumer()
            .topic(TOPIC_NAME)
            .subscriptionName(SUBSCRIPTION_NAME)
            .subscriptionType(SUBSCRIPTION_TYPE);

    IntStream.range(0, 999).forEach(i -> {
        Message<byte[]> msg = MessageBuilder.create()
                .setContent(String.format("message-%d", i).getBytes())
                .build();
        try {
            producer.send(msg);
        } catch (PulsarClientException e) {
            LOG.error(e.getMessage());
        }
    });

    // Consumer 1 can subscribe to the topic
    consumer1.subscribe();

    // But oops! Consumer 2 cannot due to the exclusive subscription held by consumer 1
    consumer2.subscribeAsync()
            .handle((consumer, exception) -> {
                LOG.error(exception.getMessage());
                return null;
            });
}
 

@Override
public ConsumerBuilder<T> property(String key, String value) {
    checkArgument(StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value),
            "property key/value cannot be blank");
    conf.getProperties().put(key, value);
    return this;
}
 

@Override
public ConsumerBuilder<T> patternAutoDiscoveryPeriod(int interval, TimeUnit unit) {
    checkArgument(interval >= 0, "interval needs to be >= 0");
    int intervalSeconds = (int) unit.toSeconds(interval);
    conf.setPatternAutoDiscoveryPeriod(intervalSeconds);
    return this;
}
 

/**
 * Verify that JavaInstance does not support functions that take Void type as input.
 */
private static PulsarClientImpl getPulsarClient() throws PulsarClientException {
    PulsarClientImpl pulsarClient = mock(PulsarClientImpl.class);
    ConsumerBuilder<?> goodConsumerBuilder = mock(ConsumerBuilder.class);
    ConsumerBuilder<?> badConsumerBuilder = mock(ConsumerBuilder.class);
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).topics(argThat(new TopicMatcher("persistent://sample/ns1/test_result")));
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).topics(argThat(new TopicMatcher("persistent://sample/ns1/test_result1")));
    doReturn(badConsumerBuilder).when(goodConsumerBuilder).topics(argThat(new TopicMatcher("persistent://sample/ns1/test_result2")));
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).topics(argThat(new TopicMatcher("persistent://sample/ns1/test_result3")));
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).cryptoFailureAction(any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).subscriptionName(any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).subscriptionInitialPosition(any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).subscriptionType(any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).ackTimeout(anyLong(), any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).messageListener(any());
    doReturn(goodConsumerBuilder).when(goodConsumerBuilder).properties(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).cryptoFailureAction(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).subscriptionName(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).subscriptionInitialPosition(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).subscriptionType(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).ackTimeout(anyLong(), any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).messageListener(any());
    doReturn(badConsumerBuilder).when(badConsumerBuilder).properties(any());

    Consumer<?> consumer = mock(Consumer.class);
    doReturn(consumer).when(goodConsumerBuilder).subscribe();
    doReturn(goodConsumerBuilder).when(pulsarClient).newConsumer(any());
    doReturn(CompletableFuture.completedFuture(consumer)).when(goodConsumerBuilder).subscribeAsync();
    CompletableFuture<Consumer<?>> badFuture = new CompletableFuture<>();
    badFuture.completeExceptionally(new PulsarClientException("Some Error"));
    doReturn(badFuture).when(badConsumerBuilder).subscribeAsync();
    doThrow(PulsarClientException.class).when(badConsumerBuilder).subscribe();
    doReturn(CompletableFuture.completedFuture(Optional.empty())).when(pulsarClient).getSchema(anyString());
    return pulsarClient;
}
 

@Override
public ConsumerBuilder<T> intercept(ConsumerInterceptor<T>... interceptors) {
    if (interceptorList == null) {
        interceptorList = new ArrayList<>();
    }
    interceptorList.addAll(Arrays.asList(interceptors));
    return this;
}
 

private ConsumerBuilder<byte[]> getConsumerConfiguration(PulsarClient client) {
    ConsumerBuilder<byte[]> builder = client.newConsumer();

    if (queryParams.containsKey("ackTimeoutMillis")) {
        builder.ackTimeout(Integer.parseInt(queryParams.get("ackTimeoutMillis")), TimeUnit.MILLISECONDS);
    }

    if (queryParams.containsKey("subscriptionType")) {
        checkArgument(Enums.getIfPresent(SubscriptionType.class, queryParams.get("subscriptionType")).isPresent(),
                "Invalid subscriptionType %s", queryParams.get("subscriptionType"));
        builder.subscriptionType(SubscriptionType.valueOf(queryParams.get("subscriptionType")));
    }

    if (queryParams.containsKey("receiverQueueSize")) {
        builder.receiverQueueSize(Math.min(Integer.parseInt(queryParams.get("receiverQueueSize")), 1000));
    }

    if (queryParams.containsKey("consumerName")) {
        builder.consumerName(queryParams.get("consumerName"));
    }

    if (queryParams.containsKey("priorityLevel")) {
        builder.priorityLevel(Integer.parseInt(queryParams.get("priorityLevel")));
    }

    if (queryParams.containsKey("maxRedeliverCount") || queryParams.containsKey("deadLetterTopic")) {
        DeadLetterPolicy.DeadLetterPolicyBuilder dlpBuilder = DeadLetterPolicy.builder();
        if (queryParams.containsKey("maxRedeliverCount")) {
            dlpBuilder.maxRedeliverCount(Integer.parseInt(queryParams.get("maxRedeliverCount")))
                    .deadLetterTopic(String.format("%s-%s-DLQ", topic, subscription));
        }

        if (queryParams.containsKey("deadLetterTopic")) {
            dlpBuilder.deadLetterTopic(queryParams.get("deadLetterTopic"));
        }
        builder.deadLetterPolicy(dlpBuilder.build());
    }

    return builder;
}
 

public static ConsumerBuilder<byte[]> getConsumerBuilder(PulsarClient client, Properties properties) {
    ConsumerBuilder<byte[]> consumerBuilder = client.newConsumer();

    if (properties.containsKey(CONSUMER_NAME)) {
        consumerBuilder.consumerName(properties.getProperty(CONSUMER_NAME));
    }

    if (properties.containsKey(RECEIVER_QUEUE_SIZE)) {
        consumerBuilder.receiverQueueSize(Integer.parseInt(properties.getProperty(RECEIVER_QUEUE_SIZE)));
    }

    if (properties.containsKey(TOTAL_RECEIVER_QUEUE_SIZE_ACROSS_PARTITIONS)) {
        consumerBuilder.maxTotalReceiverQueueSizeAcrossPartitions(
                Integer.parseInt(properties.getProperty(TOTAL_RECEIVER_QUEUE_SIZE_ACROSS_PARTITIONS)));
    }

    if (properties.containsKey(ACKNOWLEDGEMENTS_GROUP_TIME_MILLIS)) {
        consumerBuilder.acknowledgmentGroupTime(
                Long.parseLong(properties.getProperty(ACKNOWLEDGEMENTS_GROUP_TIME_MILLIS)), TimeUnit.MILLISECONDS);
    }

    if (properties.containsKey(SUBSCRIPTION_TOPICS_MODE)) {
        RegexSubscriptionMode mode;
        try {
            mode = RegexSubscriptionMode.valueOf(properties.getProperty(SUBSCRIPTION_TOPICS_MODE));
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Illegal subscription mode, valid values are: "
                + Arrays.asList(RegexSubscriptionMode.values()));
        }
        consumerBuilder.subscriptionTopicsMode(mode);
    }

    return consumerBuilder;
}
 

public static ConsumerBuilder<byte[]> getConsumerBuilder(PulsarClient client, Properties properties) {
    ConsumerBuilder<byte[]> consumerBuilder = client.newConsumer();

    if (properties.containsKey(CONSUMER_NAME)) {
        consumerBuilder.consumerName(properties.getProperty(CONSUMER_NAME));
    }

    if (properties.containsKey(RECEIVER_QUEUE_SIZE)) {
        consumerBuilder.receiverQueueSize(Integer.parseInt(properties.getProperty(RECEIVER_QUEUE_SIZE)));
    }

    if (properties.containsKey(TOTAL_RECEIVER_QUEUE_SIZE_ACROSS_PARTITIONS)) {
        consumerBuilder.maxTotalReceiverQueueSizeAcrossPartitions(
                Integer.parseInt(properties.getProperty(TOTAL_RECEIVER_QUEUE_SIZE_ACROSS_PARTITIONS)));
    }

    if (properties.containsKey(ACKNOWLEDGEMENTS_GROUP_TIME_MILLIS)) {
        consumerBuilder.acknowledgmentGroupTime(
                Long.parseLong(properties.getProperty(ACKNOWLEDGEMENTS_GROUP_TIME_MILLIS)), TimeUnit.MILLISECONDS);
    }

    if (properties.containsKey(SUBSCRIPTION_TOPICS_MODE)) {
        RegexSubscriptionMode mode;
        try {
            mode = RegexSubscriptionMode.valueOf(properties.getProperty(SUBSCRIPTION_TOPICS_MODE));
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Illegal subscription mode, valid values are: "
                + Arrays.asList(RegexSubscriptionMode.values()));
        }
        consumerBuilder.subscriptionTopicsMode(mode);
    }

    return consumerBuilder;
}
 

@Override
public ConsumerBuilder<T> autoUpdatePartitions(boolean autoUpdate) {
    conf.setAutoUpdatePartitions(autoUpdate);
    return this;
}
 

@Override

    public ConsumerBuilder<T> startMessageIdInclusive() {
        conf.setResetIncludeHead(true);
        return this;
    }
 

@Override
public ConsumerBuilder<T> subscriptionTopicsMode(@NonNull RegexSubscriptionMode mode) {
    conf.setRegexSubscriptionMode(mode);
    return this;
}
 

@Override
public ConsumerBuilder<T> enableRetry(boolean retryEnable) {
    conf.setRetryEnable(retryEnable);
    return this;
}
 

@Override
public ConsumerBuilder<T> expireTimeOfIncompleteChunkedMessage(long duration, TimeUnit unit) {
    conf.setExpireTimeOfIncompleteChunkedMessageMillis(unit.toMillis(duration));
    return null;
}
 

@Override
public ConsumerBuilder<T> patternAutoDiscoveryPeriod(int periodInMinutes) {
    checkArgument(periodInMinutes >= 0, "periodInMinutes needs to be >= 0");
    patternAutoDiscoveryPeriod(periodInMinutes, TimeUnit.MINUTES);
    return this;
}
 

@Test
public void testConsumerInstantiation() {
    ConsumerBuilder<String> stringConsumerBuilder = client.newConsumer(new StringSchema())
            .topic(TEST_TOPIC);
    Assert.assertNotNull(stringConsumerBuilder);
}
 

@Override
public ConsumerBuilder<T> acknowledgmentGroupTime(long delay, TimeUnit unit) {
    checkArgument(delay >= 0, "acknowledgmentGroupTime needs to be >= 0");
    conf.setAcknowledgementsGroupTimeMicros(unit.toMicros(delay));
    return this;
}
 

@Override
public ConsumerBuilder<T> cryptoFailureAction(@NonNull ConsumerCryptoFailureAction action) {
    conf.setCryptoFailureAction(action);
    return this;
}
 

@Override
public ConsumerBuilder<T> negativeAckRedeliveryDelay(long redeliveryDelay, TimeUnit timeUnit) {
    checkArgument(redeliveryDelay >= 0, "redeliveryDelay needs to be >= 0");
    conf.setNegativeAckRedeliveryDelayMicros(timeUnit.toMicros(redeliveryDelay));
    return this;
}
 

@Override
public ConsumerBuilder<T> loadConf(Map<String, Object> config) {
    this.conf = ConfigurationDataUtils.loadData(config, conf, ConsumerConfigurationData.class);
    return this;
}
 

@Override
public ConsumerBuilder<T> clone() {
    return new ConsumerBuilderImpl<>(client, conf.clone(), schema);
}
 

@Override
public <T> ConsumerBuilder<T> newConsumer(Schema<T> schema) {
    return new ConsumerBuilderImpl<>(this, schema);
}
 

@Override
public ConsumerBuilder<byte[]> newConsumer() {
    return new ConsumerBuilderImpl<>(this, Schema.BYTES);
}
 

@BeforeMethod
public void setup() throws PulsarClientException {
    mockClient = mock(PulsarClientImpl.class);

    mockConsumer = mock(ConsumerImpl.class);
    ConsumerBuilder<byte[]> mockConsumerBuilder = mock(ConsumerBuilder.class);

    when(mockConsumerBuilder.topic(anyString())).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.subscriptionName(anyString())).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.subscriptionType(any(SubscriptionType.class))).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.property(anyString(), anyString())).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.consumerName(anyString())).thenReturn(mockConsumerBuilder);

    when(mockConsumerBuilder.subscribe()).thenReturn(mockConsumer);
    WorkerService workerService = mock(WorkerService.class);
    doReturn(workerConfig).when(workerService).getWorkerConfig();

    listenerHolder = new AtomicReference<>();
    when(mockConsumerBuilder.consumerEventListener(any(ConsumerEventListener.class))).thenAnswer(invocationOnMock -> {

        ConsumerEventListener listener = invocationOnMock.getArgument(0);
        listenerHolder.set(listener);

        return mockConsumerBuilder;
    });

    when(mockClient.newConsumer()).thenReturn(mockConsumerBuilder);

    schedulerManager = mock(SchedulerManager.class);

    functionAssignmentTailer = mock(FunctionAssignmentTailer.class);
    readToTheEndAndExitFuture = mock(CompletableFuture.class);
    when(functionAssignmentTailer.triggerReadToTheEndAndExit()).thenReturn(readToTheEndAndExitFuture);

    functionRuntimeManager = mock(FunctionRuntimeManager.class);
    functionMetadataManager = mock(FunctionMetaDataManager.class);

    metadataManagerInitFuture = mock(CompletableFuture.class);
    runtimeManagerInitFuture = mock(CompletableFuture.class);

    when(functionMetadataManager.getIsInitialized()).thenReturn(metadataManagerInitFuture);
    when(functionRuntimeManager.getIsInitialized()).thenReturn(runtimeManagerInitFuture);

    leaderService = spy(new LeaderService(workerService, mockClient, functionAssignmentTailer, schedulerManager,
      functionRuntimeManager, functionMetadataManager,  ErrorNotifier.getDefaultImpl()));
    leaderService.start();
}
 

private static PulsarClient mockPulsarClient() throws PulsarClientException {
    PulsarClientImpl mockClient = mock(PulsarClientImpl.class);

    ConsumerImpl<byte[]> mockConsumer = mock(ConsumerImpl.class);
    ConsumerBuilder<byte[]> mockConsumerBuilder = mock(ConsumerBuilder.class);

    when(mockConsumerBuilder.topic(anyString())).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.subscriptionName(anyString())).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.subscriptionType(any(SubscriptionType.class))).thenReturn(mockConsumerBuilder);
    when(mockConsumerBuilder.property(anyString(), anyString())).thenReturn(mockConsumerBuilder);

    when(mockConsumerBuilder.subscribe()).thenReturn(mockConsumer);

    when(mockConsumerBuilder.consumerEventListener(any(ConsumerEventListener.class))).thenReturn(mockConsumerBuilder);

    when(mockClient.newConsumer()).thenReturn(mockConsumerBuilder);

    return mockClient;
}
 

/**
 * Verify that JavaInstance does not support functions that take Void type as input.
 */
private static PulsarClientImpl getPulsarClient() throws PulsarClientException {
    PulsarClientImpl pulsarClient = mock(PulsarClientImpl.class);
    ConsumerBuilder consumerBuilder = mock(ConsumerBuilder.class);
    doReturn(consumerBuilder).when(consumerBuilder).topics(anyList());
    doReturn(consumerBuilder).when(consumerBuilder).subscriptionName(anyString());
    doReturn(consumerBuilder).when(consumerBuilder).subscriptionType(any());
    doReturn(consumerBuilder).when(consumerBuilder).ackTimeout(anyLong(), any());
    Consumer consumer = mock(Consumer.class);
    doReturn(consumer).when(consumerBuilder).subscribe();
    doReturn(consumerBuilder).when(pulsarClient).newConsumer(any());
    doReturn(CompletableFuture.completedFuture(Optional.empty())).when(pulsarClient).getSchema(anyString());

    ProducerBuilder producerBuilder = mock(ProducerBuilder.class);
    doReturn(producerBuilder).when(producerBuilder).blockIfQueueFull(anyBoolean());
    doReturn(producerBuilder).when(producerBuilder).enableBatching(anyBoolean());
    doReturn(producerBuilder).when(producerBuilder).batchingMaxPublishDelay(anyLong(), any());
    doReturn(producerBuilder).when(producerBuilder).compressionType(any());
    doReturn(producerBuilder).when(producerBuilder).hashingScheme(any());
    doReturn(producerBuilder).when(producerBuilder).messageRoutingMode(any());
    doReturn(producerBuilder).when(producerBuilder).messageRouter(any());
    doReturn(producerBuilder).when(producerBuilder).topic(anyString());
    doReturn(producerBuilder).when(producerBuilder).producerName(anyString());
    doReturn(producerBuilder).when(producerBuilder).property(anyString(), anyString());
    doReturn(producerBuilder).when(producerBuilder).properties(any());
    doReturn(producerBuilder).when(producerBuilder).sendTimeout(anyInt(), any());

    CompletableFuture completableFuture = new CompletableFuture<>();
    completableFuture.complete(mock(MessageId.class));
    TypedMessageBuilder typedMessageBuilder = mock(TypedMessageBuilder.class);
    doReturn(completableFuture).when(typedMessageBuilder).sendAsync();

    Producer producer = mock(Producer.class);
    doReturn(producer).when(producerBuilder).create();
    doReturn(typedMessageBuilder).when(producer).newMessage();

    doReturn(producerBuilder).when(pulsarClient).newProducer();
    doReturn(producerBuilder).when(pulsarClient).newProducer(any());

    return pulsarClient;
}
 

private int consume(String topic) {
    int numMessagesConsumed = 0;
    int returnCode = 0;

    try {
        PulsarClient client = clientBuilder.build();
        ConsumerBuilder<byte[]> builder = client.newConsumer()
                .subscriptionName(this.subscriptionName)
                .subscriptionType(subscriptionType)
                .subscriptionInitialPosition(subscriptionInitialPosition);

        if (isRegex) {
            builder.topicsPattern(Pattern.compile(topic));
        } else {
            builder.topic(topic);
        }

        ConsumerBuilder<byte[]> consumerBuilder = client.newConsumer().topic(topic);
        if (this.maxPendingChuckedMessage > 0) {
            consumerBuilder.maxPendingChuckedMessage(this.maxPendingChuckedMessage);
        }
        if (this.receiverQueueSize > 0) {
            consumerBuilder.maxPendingChuckedMessage(this.receiverQueueSize);
        }
        Consumer<byte[]> consumer = consumerBuilder.subscriptionName(this.subscriptionName)
                .autoAckOldestChunkedMessageOnQueueFull(this.autoAckOldestChunkedMessageOnQueueFull)
                .subscriptionType(subscriptionType).subscribe();

        RateLimiter limiter = (this.consumeRate > 0) ? RateLimiter.create(this.consumeRate) : null;
        while (this.numMessagesToConsume == 0 || numMessagesConsumed < this.numMessagesToConsume) {
            if (limiter != null) {
                limiter.acquire();
            }

            Message<byte[]> msg = consumer.receive(5, TimeUnit.SECONDS);
            if (msg == null) {
                LOG.debug("No message to consume after waiting for 5 seconds.");
            } else {
                numMessagesConsumed += 1;
                System.out.println(MESSAGE_BOUNDARY);
                String output = this.interpretMessage(msg, displayHex);
                System.out.println(output);
                consumer.acknowledge(msg);
            }
        }
        client.close();
    } catch (Exception e) {
        LOG.error("Error while consuming messages");
        LOG.error(e.getMessage(), e);
        returnCode = -1;
    } finally {
        LOG.info("{} messages successfully consumed", numMessagesConsumed);
    }

    return returnCode;

}