io.paradoxical.rabbitmq.queues.CallbackBasedQueueConsumer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rabbitmq Show documentation
A simplified RMQ client library
The newest version!
package io.paradoxical.rabbitmq.queues;

import io.paradoxical.rabbitmq.EventProcessor;
import io.paradoxical.rabbitmq.ListenerOptions;
import io.paradoxical.rabbitmq.RabbitRawMessage;
import io.paradoxical.rabbitmq.SingleQueueConfiguration;
import io.paradoxical.rabbitmq.connectionManagment.ChannelProvider;
import io.paradoxical.rabbitmq.results.MessageResult;
import com.godaddy.logging.Logger;
import com.rabbitmq.client.QueueingConsumer;

import java.io.IOException;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

import static com.godaddy.logging.LoggerFactory.getLogger;

public class CallbackBasedQueueConsumer extends BlockingQueueConsumerSyncBase implements AutoCloseable {

    private static final Logger logger = getLogger(CallbackBasedQueueConsumer.class);

    public CallbackBasedQueueConsumer(
            final ChannelProvider channelProvider,
            final SingleQueueConfiguration info, final Class target)
            throws IOException, InterruptedException, NoSuchAlgorithmException, KeyManagementException, URISyntaxException {
        super(channelProvider, info, target);
    }

    public CallbackBasedQueueConsumer(final ChannelProvider channelProvider, final SingleQueueConfiguration info, final Class target, final ListenerOptions options)
            throws IOException, InterruptedException, NoSuchAlgorithmException, KeyManagementException, URISyntaxException {
        super(channelProvider, info, target, options);
    }

    /**
     * Manually invoke pulling an event off the wire and block up to the duration
     *
     * Returns true if a message was consumed
     *
     * @param timeout
     */
    public synchronized boolean pullNextBlockingRmqMessage(Duration timeout, EventProcessor processor) {
        try {
            if (consumer != null) {
                QueueingConsumer.Delivery delivery = consumer.getConsumer().nextDelivery(timeout.toMillis());

                // timeout
                if (delivery == null) {
                    return false;
                }

                RabbitRawMessage rabbitRawMessage = new RabbitRawMessage(consumer.getConsumer().getConsumerTag(),
                                                                         delivery.getEnvelope(),
                                                                         delivery.getProperties(),
                                                                         delivery.getBody(),
                                                                         consumer.getExchange());

                deliveryHandler(consumer.getConsumer().getChannel(),
                                consumer.getQueue(),
                                rabbitRawMessage,
                                msg -> {
                                    MessageResult messageResult = processor.handleMessage(msg);

                                    return CompletableFuture.completedFuture(messageResult);
                                });

                return true;
            }
        }
        catch (Throwable ex) {
            logger.error(ex, "Error getting message!");
        }

        return false;
    }
}