/*
* *************************************************************************************
* 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.dataflow.ops;
import com.espertech.esper.client.EventBean;
import com.espertech.esper.client.EventType;
import com.espertech.esper.client.dataflow.EPDataFlowSignalFinalMarker;
import com.espertech.esper.core.service.StatementContext;
import com.espertech.esper.dataflow.annotations.DataFlowContext;
import com.espertech.esper.dataflow.annotations.DataFlowOpParameter;
import com.espertech.esper.dataflow.annotations.DataFlowOperator;
import com.espertech.esper.dataflow.interfaces.*;
import com.espertech.esper.dataflow.util.GraphTypeDesc;
import com.espertech.esper.epl.expression.*;
import com.espertech.esper.event.EventBeanManufacturer;
import com.espertech.esper.event.EventTypeUtility;
import com.espertech.esper.event.WriteablePropertyDescriptor;
import com.espertech.esper.util.TypeWidener;
import com.espertech.esper.util.TypeWidenerFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.*;
@DataFlowOperator
public class BeaconSource implements DataFlowSourceOperator {
private static final Log log = LogFactory.getLog(BeaconSource.class);
private final static List<String> PARAMETER_PROPERTIES = Arrays.asList("interval", "iterations", "initialDelay");
@DataFlowContext
private EPDataFlowEmitter graphContext;
@DataFlowOpParameter
private long iterations;
@DataFlowOpParameter
private double initialDelay;
@DataFlowOpParameter
private double interval;
private Map<String, Object> allProperties = new LinkedHashMap<String, Object>();
private long initialDelayMSec;
private long periodDelayMSec;
private long lastSendTime;
private long iterationNumber;
private boolean produceEventBean;
private ExprEvaluator[] evaluators;
private EventBeanManufacturer manufacturer;
@DataFlowOpParameter(all=true)
public void setProperty(String name, Object value) {
allProperties.put(name, value);
}
public DataFlowOpInitializeResult initialize(DataFlowOpInitializateContext context) throws Exception {
initialDelayMSec = (long) (initialDelay * 1000);
periodDelayMSec = (long) (interval * 1000);
if (context.getOutputPorts().size() != 1) {
throw new IllegalArgumentException("BeaconSource operator requires one output stream but produces " + context.getOutputPorts().size() + " streams");
}
// Check if a type is declared
DataFlowOpOutputPort port = context.getOutputPorts().get(0);
if (port.getOptionalDeclaredType() != null && port.getOptionalDeclaredType().getEventType() != null) {
EventType outputEventType = port.getOptionalDeclaredType().getEventType();
produceEventBean = port.getOptionalDeclaredType() != null && !port.getOptionalDeclaredType().isUnderlying();
// compile properties to populate
Set<String> props = allProperties.keySet();
props.removeAll(PARAMETER_PROPERTIES);
WriteablePropertyDescriptor[] writables = setupProperties(props.toArray(new String[props.size()]), outputEventType, context.getStatementContext());
manufacturer = context.getServicesContext().getEventAdapterService().getManufacturer(outputEventType, writables, context.getServicesContext().getEngineImportService(), false);
int index = 0;
evaluators = new ExprEvaluator[writables.length];
for (WriteablePropertyDescriptor writeable : writables) {
final Object providedProperty = allProperties.get(writeable.getPropertyName());
if (providedProperty instanceof ExprNode) {
ExprNode exprNode = (ExprNode) providedProperty;
ExprNode validated = ExprNodeUtility.validateSimpleGetSubtree("Beacon parameter", exprNode, context.getStatementContext(), null);
final ExprEvaluator exprEvaluator = validated.getExprEvaluator();
final TypeWidener widener = TypeWidenerFactory.getCheckPropertyAssignType(validated.toExpressionString(), exprEvaluator.getType(),
writeable.getType(), writeable.getPropertyName());
if (widener != null) {
evaluators[index] = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext context) {
Object value = exprEvaluator.evaluate(eventsPerStream, isNewData, context);
return widener.widen(value);
}
public Class getType() {
return null;
}
};
}
else {
evaluators[index] = exprEvaluator;
}
}
else if (providedProperty == null) {
evaluators[index] = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext context) {
return null;
}
public Class getType() {
return null;
}
};
}
else {
evaluators[index] = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext context) {
return providedProperty;
}
public Class getType() {
return providedProperty.getClass();
}
};
}
index++;
}
return null; // no changing types
}
// No type has been declared, we can create one
String anonymousTypeName = context.getDataflowName() + "-beacon";
Map<String, Object> types = new LinkedHashMap<String, Object>();
Set<String> props = allProperties.keySet();
props.removeAll(PARAMETER_PROPERTIES);
int count = 0;
evaluators = new ExprEvaluator[props.size()];
for (String propertyName : props) {
ExprNode exprNode = (ExprNode) allProperties.get(propertyName);
ExprNode validated = ExprNodeUtility.validateSimpleGetSubtree("Beacon parameter", exprNode, context.getStatementContext(), null);
final Object value = validated.getExprEvaluator().evaluate(null, true, context.getAgentInstanceContext());
if (value == null) {
types.put(propertyName, null);
}
else {
types.put(propertyName, value.getClass());
}
evaluators[count] = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext context) {
return value;
}
public Class getType() {
return null;
}
};
count++;
}
EventType type = context.getServicesContext().getEventAdapterService().createAnonymousObjectArrayType(anonymousTypeName, types);
return new DataFlowOpInitializeResult(new GraphTypeDesc[] {new GraphTypeDesc(false, true, type)});
}
public void next() {
if (iterationNumber == 0 && initialDelayMSec > 0) {
try {
Thread.sleep(initialDelayMSec, 0);
}
catch (InterruptedException e) {
graphContext.submitSignal(new EPDataFlowSignalFinalMarker() {});
}
}
if (iterationNumber > 0 && periodDelayMSec > 0) {
long nsecDelta = lastSendTime - System.nanoTime();
long sleepTime = periodDelayMSec - nsecDelta / 1000000;
if (sleepTime > 0) {
try {
Thread.sleep(sleepTime);
}
catch (InterruptedException e) {
graphContext.submitSignal(new EPDataFlowSignalFinalMarker() {});
}
}
}
if (iterations > 0 && iterationNumber >= iterations) {
graphContext.submitSignal(new EPDataFlowSignalFinalMarker() {});
}
else {
iterationNumber++;
if (evaluators != null) {
Object[] row = new Object[evaluators.length];
for (int i = 0; i < row.length; i++) {
if (evaluators[i] != null) {
row[i] = evaluators[i].evaluate(null, true, null);
}
}
if (log.isDebugEnabled()) {
log.debug("BeaconSource submitting row " + Arrays.toString(row));
}
Object outputEvent = row;
if (manufacturer != null) {
if (!produceEventBean) {
outputEvent = manufacturer.makeUnderlying(row);
}
else {
outputEvent = manufacturer.make(row);
}
}
graphContext.submit(outputEvent);
}
else {
if (log.isDebugEnabled()) {
log.debug("BeaconSource submitting empty row");
}
graphContext.submit(new Object[0]);
}
if (interval > 0) {
lastSendTime = System.nanoTime();
}
}
}
public void open(DataFlowOpOpenContext openContext) {
// no action
}
public void close(DataFlowOpCloseContext openContext) {
// no action
}
private static WriteablePropertyDescriptor[] setupProperties(String[] propertyNamesOffered, EventType outputEventType, StatementContext statementContext)
throws ExprValidationException
{
Set<WriteablePropertyDescriptor> writeables = statementContext.getEventAdapterService().getWriteableProperties(outputEventType, false);
List<WriteablePropertyDescriptor> writablesList = new ArrayList<WriteablePropertyDescriptor>();
for (int i = 0; i < propertyNamesOffered.length; i++) {
String propertyName = propertyNamesOffered[i];
WriteablePropertyDescriptor writable = EventTypeUtility.findWritable(propertyName, writeables);
if (writable == null) {
throw new ExprValidationException("Failed to find writable property '" + propertyName + "' for event type '" + outputEventType.getName() + "'");
}
writablesList.add(writable);
}
return writablesList.toArray(new WriteablePropertyDescriptor[writablesList.size()]);
}
}