/**************************************************************************************
* Copyright (C) 2008 EsperTech, Inc. All rights reserved. *
* http://esper.codehaus.org *
* http://www.espertech.com *
* ---------------------------------------------------------------------------------- *
* The software in this package is published under the terms of the GPL license *
* a copy of which has been included with this distribution in the license.txt file. *
**************************************************************************************/
package com.espertech.esper.view.window;
import com.espertech.esper.client.EventBean;
import com.espertech.esper.client.EventType;
import com.espertech.esper.core.context.util.AgentInstanceViewFactoryChainContext;
import com.espertech.esper.core.service.EPStatementHandleCallback;
import com.espertech.esper.core.service.ExtensionServicesContext;
import com.espertech.esper.metrics.instrumentation.InstrumentationHelper;
import com.espertech.esper.schedule.ScheduleHandleCallback;
import com.espertech.esper.schedule.ScheduleSlot;
import com.espertech.esper.util.StopCallback;
import com.espertech.esper.view.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Set;
/**
* A data window view that holds events in a stream and only removes events from a stream (rstream) if
* no more events arrive for a given time interval, also handling the remove stream
* by keeping set-like semantics. See {@link TimeAccumView} for the same behavior without
* remove stream handling.
*/
public class TimeAccumViewRStream extends ViewSupport implements CloneableView, DataWindowView, StoppableView, StopCallback
{
// View parameters
private final TimeAccumViewFactory factory;
protected final AgentInstanceViewFactoryChainContext agentInstanceContext;
protected final long msecIntervalSize;
protected final ScheduleSlot scheduleSlot;
// Current running parameters
protected LinkedHashMap<EventBean, Long> currentBatch = new LinkedHashMap<EventBean, Long>();
protected EventBean lastEvent;
protected long callbackScheduledTime;
protected EPStatementHandleCallback handle;
/**
* Constructor.
* @param msecIntervalSize is the number of milliseconds to batch events for
* @param timeBatchViewFactory fr copying this view in a group-by
*/
public TimeAccumViewRStream(TimeAccumViewFactory timeBatchViewFactory,
AgentInstanceViewFactoryChainContext agentInstanceContext,
long msecIntervalSize)
{
this.agentInstanceContext = agentInstanceContext;
this.factory = timeBatchViewFactory;
this.msecIntervalSize = msecIntervalSize;
this.scheduleSlot = agentInstanceContext.getStatementContext().getScheduleBucket().allocateSlot();
ScheduleHandleCallback callback = new ScheduleHandleCallback() {
public void scheduledTrigger(ExtensionServicesContext extensionServicesContext)
{
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().qViewScheduledEval(TimeAccumViewRStream.this, TimeAccumViewRStream.this.factory.getViewName());}
TimeAccumViewRStream.this.sendRemoveStream();
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().aViewScheduledEval();}
}
};
handle = new EPStatementHandleCallback(agentInstanceContext.getEpStatementAgentInstanceHandle(), callback);
agentInstanceContext.addTerminationCallback(this);
}
public View cloneView()
{
return factory.makeView(agentInstanceContext);
}
/**
* Returns the interval size in milliseconds.
* @return batch size
*/
public final long getMsecIntervalSize()
{
return msecIntervalSize;
}
public final EventType getEventType()
{
return parent.getEventType();
}
public void update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().qViewProcessIRStream(this, factory.getViewName(), newData, oldData);}
if ((newData != null) && (newData.length > 0))
{
// If we have an empty window about to be filled for the first time, add a callback
boolean removeSchedule = false;
boolean addSchedule = false;
long timestamp = agentInstanceContext.getStatementContext().getSchedulingService().getTime();
// if the window is already filled, then we may need to reschedule
if (!currentBatch.isEmpty())
{
// check if we need to reschedule
long callbackTime = timestamp + msecIntervalSize;
if (callbackTime != callbackScheduledTime)
{
removeSchedule = true;
addSchedule = true;
}
}
else
{
addSchedule = true;
}
if (removeSchedule)
{
agentInstanceContext.getStatementContext().getSchedulingService().remove(handle, scheduleSlot);
callbackScheduledTime = -1;
}
if (addSchedule)
{
agentInstanceContext.getStatementContext().getSchedulingService().add(msecIntervalSize, handle, scheduleSlot);
callbackScheduledTime = msecIntervalSize + timestamp;
}
// add data points to the window
for (int i = 0; i < newData.length; i++)
{
currentBatch.put(newData[i], timestamp);
internalHandleAdded(newData[i], timestamp);
lastEvent = newData[i];
}
}
if ((oldData != null) && (oldData.length > 0))
{
boolean removedLastEvent = false;
for (EventBean anOldData : oldData)
{
currentBatch.remove(anOldData);
internalHandleRemoved(anOldData);
if (anOldData == lastEvent)
{
removedLastEvent = true;
}
}
// we may need to reschedule as the newest event may have been deleted
if (currentBatch.size() == 0)
{
agentInstanceContext.getStatementContext().getSchedulingService().remove(handle, scheduleSlot);
callbackScheduledTime = -1;
lastEvent = null;
}
else
{
// reschedule if the last event was removed
if (removedLastEvent)
{
Set<EventBean> keyset = currentBatch.keySet();
EventBean[] events = keyset.toArray(new EventBean[keyset.size()]);
lastEvent = events[events.length - 1];
long lastTimestamp = currentBatch.get(lastEvent);
// reschedule, newest event deleted
long timestamp = agentInstanceContext.getStatementContext().getSchedulingService().getTime();
long callbackTime = lastTimestamp + msecIntervalSize;
long deltaFromNow = callbackTime - timestamp;
if (callbackTime != callbackScheduledTime)
{
agentInstanceContext.getStatementContext().getSchedulingService().remove(handle, scheduleSlot);
agentInstanceContext.getStatementContext().getSchedulingService().add(deltaFromNow, handle, scheduleSlot);
callbackScheduledTime = callbackTime;
}
}
}
}
// update child views
if (this.hasViews())
{
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().qViewIndicate(this, factory.getViewName(), newData, oldData);}
updateChildren(newData, oldData);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().aViewIndicate();}
}
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().aViewProcessIRStream();}
}
public void visitView(ViewDataVisitor viewDataVisitor) {
viewDataVisitor.visitPrimary(currentBatch, true, factory.getViewName(), currentBatch.size(), null);
}
/**
* This method sends the remove stream for all accumulated events.
*/
protected void sendRemoveStream()
{
callbackScheduledTime = -1;
// If there are child views and the batch was filled, fireStatementStopped update method
if (this.hasViews())
{
// Convert to object arrays
EventBean[] oldData = null;
if (!currentBatch.isEmpty())
{
oldData = currentBatch.keySet().toArray(new EventBean[currentBatch.size()]);
}
if (oldData != null)
{
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().qViewIndicate(this, factory.getViewName(), null, oldData);}
updateChildren(null, oldData);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.get().aViewIndicate();}
}
}
currentBatch.clear();
}
/**
* Returns true if the window is empty, or false if not empty.
* @return true if empty
*/
public boolean isEmpty()
{
return currentBatch.isEmpty();
}
public final Iterator<EventBean> iterator()
{
return currentBatch.keySet().iterator();
}
public final String toString()
{
return this.getClass().getName() + " msecIntervalSize=" + msecIntervalSize;
}
public void stopView() {
stopSchedule();
agentInstanceContext.removeTerminationCallback(this);
}
public void stop() {
stopSchedule();
}
public void stopSchedule() {
if (handle != null) {
agentInstanceContext.getStatementContext().getSchedulingService().remove(handle, scheduleSlot);
}
}
public void internalHandleRemoved(EventBean anOldData) {
// no action required
}
public void internalHandleAdded(EventBean eventBean, long timestamp) {
// no action required
}
private static final Log log = LogFactory.getLog(TimeAccumViewRStream.class);
}