EmitterRuntimeEnvironment.java

/**
 * Copyright 2015 Otto (GmbH & Co KG)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.ottogroup.bi.spqr.pipeline.component.emitter;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

import com.codahale.metrics.Counter;
import com.codahale.metrics.Timer;
import com.ottogroup.bi.spqr.exception.RequiredInputMissingException;
import com.ottogroup.bi.spqr.pipeline.message.StreamingDataMessage;
import com.ottogroup.bi.spqr.pipeline.queue.StreamingMessageQueueConsumer;
import com.ottogroup.bi.spqr.pipeline.queue.strategy.StreamingMessageQueueWaitStrategy;

/**
 * Provides a runtime environment for {@link Emitter} instances. The environment retrieves all
 * incoming {@link StreamingDataMessage} instances from the attached {@link StreamingMessageQueueConsumer}
 * and provides them to the assigned {@link Emitter} for further processing.
 * @author mnxfst
 *
 */
public class EmitterRuntimeEnvironment implements Runnable {

	/** our faithful logging facility ... ;-) */ 
	private static final Logger logger = Logger.getLogger(EmitterRuntimeEnvironment.class);

	/** identifier of processing node the runtime environment belongs to*/
	private final String processingNodeId;
	/** identifier of pipeline the runtime environment belongs to */
	private final String pipelineId;
	/** identifier of emitter assigned to this runtime environment */
	private final String emitterId; 
	/** reference to emitter instance being fed with incoming messages */
	private final Emitter emitter;
	/** provides read access to assigned source queue */
	private final StreamingMessageQueueConsumer queueConsumer;
	/** indicates whether the environment is still running */
	private boolean running = false;
	/** message counter metric */
	private Counter messageCounter = null;
	/** insertion timer metric */
	private Timer messageEmitDurationTimer = null;


	/**
	 * Initializes the runtime environment using the provided input
	 * @param processingNodeId
	 * @param pipelineId
	 * @param emitter
	 * @param queueConsumer
	 * @throws RequiredInputMissingException
	 */
	public EmitterRuntimeEnvironment(final String processingNodeId, final String pipelineId, final Emitter emitter, 
			final StreamingMessageQueueConsumer queueConsumer) throws RequiredInputMissingException {
		
		///////////////////////////////////////////////////////////////////
		// validate input
		if(StringUtils.isBlank(processingNodeId))
			throw new RequiredInputMissingException("Missing required processing node identifier");
		if(StringUtils.isBlank(pipelineId))
			throw new RequiredInputMissingException("Missing required pipeline identifier");
		if(emitter == null)
			throw new RequiredInputMissingException("Missing required emitter");
		if(queueConsumer == null)
			throw new RequiredInputMissingException("Missing required input queue consumer");
		//
		///////////////////////////////////////////////////////////////////

		this.processingNodeId = StringUtils.lowerCase(StringUtils.trim(processingNodeId));
		this.pipelineId = StringUtils.lowerCase(StringUtils.trim(pipelineId));
		this.emitterId = StringUtils.lowerCase(StringUtils.trim(emitter.getId()));
		this.emitter = emitter;
		this.queueConsumer = queueConsumer;
		
		this.running = true;
		
		if(logger.isDebugEnabled())
			logger.debug("emitter init [node="+this.processingNodeId+", pipeline="+this.pipelineId+", emitter="+this.emitterId+"]");

	}
		
	/**
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		
		// fetch the wait strategy attached to the queue (provided through the queue consumer)
		StreamingMessageQueueWaitStrategy queueWaitStrategy = this.queueConsumer.getWaitStrategy();
		while(running) {

			try {
				// fetch message from queue consumer via strategy
				StreamingDataMessage message = queueWaitStrategy.waitFor(this.queueConsumer);
				if(message != null && message.getBody() != null) {
					
					@SuppressWarnings("resource") // context#close() calls context#stop -> avoid additional call, thus accept warning
					Timer.Context timerContext = (this.messageEmitDurationTimer != null ? this.messageEmitDurationTimer.time() : null);

					this.emitter.onMessage(message);
					
					if(timerContext != null)
						timerContext.stop();

					if(this.messageCounter != null)
						this.messageCounter.inc();
				} 

			} catch(InterruptedException e) {
				// do nothing - waiting was interrupted				
			} catch(Exception e) {
				logger.error("processing error [node="+this.processingNodeId+", pipeline="+this.pipelineId+", emitter="+this.emitterId+"]: " + e.getMessage(), e);
				// TODO add handler for responding to errors
			}
		}		
	}

	/**
	 * Shuts down the runtime environment as well as the attached {@link Emitter}
	 */
	public void shutdown() {
		this.running = false;
		try {
			this.emitter.shutdown();
			if(logger.isDebugEnabled())
				logger.debug("emitter shutdown [node="+this.processingNodeId+", pipeline="+this.pipelineId+", emitter="+this.emitterId+"]");
		} catch(Exception e) {
			logger.error("emitter shutdown error [node="+this.processingNodeId+", pipeline="+this.pipelineId+", emitter="+this.emitterId+"]: " + e.getMessage(), e);
		}

	}

	/**
	 * @return the running
	 */
	public boolean isRunning() {
		return running;
	}

	/**
	 * @param messageCounter the messageCounter to set
	 */
	public void setMessageCounter(Counter messageCounter) {
		this.messageCounter = messageCounter;
	}

	/**
	 * @param messageEmitDurationTimer the messageEmitDurationTimer to set
	 */
	public void setMessageEmitDurationTimer(Timer messageEmitDurationTimer) {
		this.messageEmitDurationTimer = messageEmitDurationTimer;
	}
	
}