com.microsoft.azure.eventhubs.ReceivePump Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of azure-eventhubs Show documentation
Client library for talking to Microsoft Azure Event Hubs.
There is a newer version: 3.3.0
/*
 * Copyright (c) Microsoft. All rights reserved.
 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
 */
package com.microsoft.azure.eventhubs;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.microsoft.azure.servicebus.ClientConstants;
import com.microsoft.azure.servicebus.ServiceBusException;

public class ReceivePump
{
	private static final Logger TRACE_LOGGER = Logger.getLogger(ClientConstants.SERVICEBUS_CLIENT_TRACE);
	
	private final IPartitionReceiver receiver;
	private final PartitionReceiveHandler onReceiveHandler;
	private final boolean invokeOnTimeout;
	private final CompletableFuture stopPump;

	private AtomicBoolean stopPumpRaised;
	
	public ReceivePump(
			final IPartitionReceiver receiver,
			final PartitionReceiveHandler receiveHandler,
			final boolean invokeOnReceiveWithNoEvents)
	{
		this.receiver = receiver;
		this.onReceiveHandler = receiveHandler;
		this.invokeOnTimeout = invokeOnReceiveWithNoEvents;
		this.stopPump = new CompletableFuture();
		
		this.stopPumpRaised = new AtomicBoolean(false);
	}	
	
	public void run()
	{
		boolean isPumpHealthy = true;
		while(isPumpHealthy && !this.stopPumpRaised.get())
		{
			Iterable receivedEvents = null;

			try
			{
				receivedEvents = this.receiver.receive(this.onReceiveHandler.getMaxEventCount());
			}
			catch (Throwable clientException)
			{
				isPumpHealthy = false;
				this.onReceiveHandler.onError(clientException);
				
				if (TRACE_LOGGER.isLoggable(Level.WARNING))
				{
					TRACE_LOGGER.log(Level.WARNING, String.format("Receive pump for partition (%s) exiting after receive exception %s", this.receiver.getPartitionId(), clientException.toString()));
				}
			}

			try
			{
				if (receivedEvents != null || (receivedEvents == null && this.invokeOnTimeout && isPumpHealthy))
				{
					this.onReceiveHandler.onReceive(receivedEvents);	
				}
			}
			catch (Throwable userCodeError)
			{
				isPumpHealthy = false;
				this.onReceiveHandler.onError(userCodeError);

				if (userCodeError instanceof InterruptedException)
				{
					if(TRACE_LOGGER.isLoggable(Level.FINE))
					{
						TRACE_LOGGER.log(Level.FINE, String.format("Interrupting receive pump for partition (%s)", this.receiver.getPartitionId()));
					}
					
					Thread.currentThread().interrupt();
				}
				else if (TRACE_LOGGER.isLoggable(Level.SEVERE))
				{
					TRACE_LOGGER.log(Level.SEVERE, String.format("Receive pump for partition (%s) exiting after user exception %s", this.receiver.getPartitionId(), userCodeError.toString()));
				}
			}
		}
		
		this.stopPump.complete(null);
	}
	
	public CompletableFuture stop()
	{
		this.stopPumpRaised.set(true);
		return this.stopPump;
	}
	
	public boolean isRunning()
	{
		return !this.stopPump.isDone();
	}

	// partition receiver contract against which this pump works
	public static interface IPartitionReceiver
	{
		public String getPartitionId();

		public Iterable receive(final int maxBatchSize) throws ServiceBusException;
	}
}