public EPDataFlowEmitterNoTarget(
int operatorNum,
DataFlowSignalManager dataFlowSignalManager)
{
this.operatorNum = operatorNum;
this.dataFlowSignalManager = dataFlowSignalManager;
}
private static EPDataFlowEmitter GenerateRuntimeContext(
string engineURI,
string statementName,
bool audit,
string dataflowName,
int producerOpNum,
string operatorPrettyPrint,
DataFlowSignalManager dataFlowSignalManager,
IList <ObjectBindingPair>[] targetsPerStream,
EPDataFlowInstantiationOptions options,
EngineImportService engineImportService)
{
// handle no targets
if (targetsPerStream == null)
{
return(new EPDataFlowEmitterNoTarget(producerOpNum, dataFlowSignalManager));
}
// handle single-stream case
if (targetsPerStream.Length == 1)
{
var targets = targetsPerStream[0];
// handle single-stream single target case
if (targets.Count == 1)
{
var target = targets[0];
return(GetSubmitHandler(
engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint,
dataFlowSignalManager, target, options.GetExceptionHandler(), engineImportService));
}
var handlers = new SubmitHandler[targets.Count];
for (var i = 0; i < handlers.Length; i++)
{
handlers[i] = GetSubmitHandler(
engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint,
dataFlowSignalManager, targets[i], options.GetExceptionHandler(), engineImportService);
}
return(new EPDataFlowEmitter1StreamNTarget(producerOpNum, dataFlowSignalManager, handlers));
}
else
{
// handle multi-stream case
var handlersPerStream = new SubmitHandler[targetsPerStream.Length][];
for (var streamNum = 0; streamNum < targetsPerStream.Length; streamNum++)
{
var handlers = new SubmitHandler[targetsPerStream[streamNum].Count];
handlersPerStream[streamNum] = handlers;
for (var i = 0; i < handlers.Length; i++)
{
handlers[i] = GetSubmitHandler(
engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint,
dataFlowSignalManager, targetsPerStream[streamNum][i], options.GetExceptionHandler(),
engineImportService);
}
}
return(new EPDataFlowEmitterNStreamNTarget(producerOpNum, dataFlowSignalManager, handlersPerStream));
}
}
public EPDataFlowEmitterNStreamNTarget(
int operatorNum,
DataFlowSignalManager signalManager,
SubmitHandler[][] handlersPerStream)
{
this.operatorNum = operatorNum;
this.signalManager = signalManager;
this.handlersPerStream = handlersPerStream;
}
public EPDataFlowEmitter1StreamNTarget(
int operatorNum,
DataFlowSignalManager signalManager,
SubmitHandler[] targets)
{
this.operatorNum = operatorNum;
this.signalManager = signalManager;
this.targets = targets;
}
public EPDataFlowEmitter1Stream1TargetUnwind(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
EngineImportService engineImportService)
: base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService)
{
}
protected EPDataFlowEmitter1Stream1TargetBase(int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target)
{
OperatorNum = operatorNum;
SignalManager = signalManager;
SignalHandler = signalHandler;
ExceptionHandler = exceptionHandler;
var fastClass = FastClass.Create(target.Target.GetType());
_fastMethod = fastClass.GetMethod(target.Binding.ConsumingBindingDesc.Method);
TargetObject = target.Target;
}
public EPDataFlowEmitter1Stream1TargetPassAlongWStream(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
int streamNum,
EngineImportService engineImportService)
: base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService)
{
_streamNum = streamNum;
}
public EPDataFlowEmitter1Stream1TargetBase(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
ImportService importService)
{
this.operatorNum = operatorNum;
this.signalManager = signalManager;
this.signalHandler = signalHandler;
this.exceptionHandler = exceptionHandler;
fastMethod = target.Binding.ConsumingBindingDesc.Method;
targetObject = target.Target;
}
public EPDataFlowEmitter1Stream1TargetPassAlong(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
ImportService importService)
: base(
operatorNum,
signalManager,
signalHandler,
exceptionHandler,
target,
importService)
{
}
private static SubmitHandler GetSubmitHandler(
string engineURI,
string statementName,
bool audit,
string dataflowName,
int producerOpNum,
string operatorPrettyPrint,
DataFlowSignalManager dataFlowSignalManager,
ObjectBindingPair target,
EPDataFlowExceptionHandler optionalExceptionHandler,
EngineImportService engineImportService)
{
var signalHandler = GetSignalHandler(
producerOpNum, target.Target, target.Binding.ConsumingSignalBindingDesc, engineImportService);
var receivingOpNum = target.Binding.LogicalChannel.ConsumingOpNum;
var receivingOpPretty = target.Binding.LogicalChannel.ConsumingOpPrettyPrint;
var receivingOpName = target.Binding.LogicalChannel.ConsumingOpName;
var exceptionHandler = new EPDataFlowEmitterExceptionHandler(
engineURI, statementName, audit, dataflowName, receivingOpName, receivingOpNum, receivingOpPretty,
optionalExceptionHandler);
var bindingType = target.Binding.ConsumingBindingDesc.BindingType;
if (bindingType is LogicalChannelBindingTypePassAlong)
{
return(new EPDataFlowEmitter1Stream1TargetPassAlong(
producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, engineImportService));
}
else if (bindingType is LogicalChannelBindingTypePassAlongWStream)
{
var type = (LogicalChannelBindingTypePassAlongWStream)bindingType;
return(new EPDataFlowEmitter1Stream1TargetPassAlongWStream(
producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, type.StreamNum,
engineImportService));
}
else if (bindingType is LogicalChannelBindingTypeUnwind)
{
return(new EPDataFlowEmitter1Stream1TargetUnwind(
producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, engineImportService));
}
else
{
throw new UnsupportedOperationException("Unsupported binding type '" + bindingType + "'");
}
}
public static DataflowStartDesc Realize(String dataFlowName,
IDictionary <int, Object> operators,
IDictionary <int, OperatorMetadataDescriptor> operatorMetadata,
ICollection <int> operatorBuildOrder,
IList <LogicalChannelBinding> bindings,
DataFlowSignalManager dataFlowSignalManager,
EPDataFlowInstantiationOptions options,
EPServicesContext services,
StatementContext statementContext)
{
// First pass: inject runtime context
IDictionary <int, EPDataFlowEmitter> runtimeContexts = new Dictionary <int, EPDataFlowEmitter>();
OperatorStatisticsProvider statisticsProvider = null;
if (options.IsOperatorStatistics())
{
statisticsProvider = new OperatorStatisticsProvider(operatorMetadata);
}
bool audit = AuditEnum.DATAFLOW_OP.GetAudit(statementContext.Annotations) != null;
foreach (int producerOpNum in operatorBuildOrder)
{
String operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint;
if (Log.IsDebugEnabled)
{
Log.Debug("Generating runtime context for " + operatorPrettyPrint);
}
// determine the number of output streams
Object producingOp = operators.Get(producerOpNum);
int numOutputStreams = operatorMetadata.Get(producerOpNum).OperatorSpec.Output.Items.Count;
IList <ObjectBindingPair>[] targets = GetOperatorConsumersPerStream(
numOutputStreams, producerOpNum, operators, operatorMetadata, bindings);
EPDataFlowEmitter runtimeContext = GenerateRuntimeContext(
statementContext.EngineURI, statementContext.StatementName, audit, dataFlowName, producerOpNum,
operatorPrettyPrint, dataFlowSignalManager, targets, options);
if (options.IsOperatorStatistics())
{
runtimeContext = new EPDataFlowEmitterWrapperWStatistics(
runtimeContext, producerOpNum, statisticsProvider, options.IsCpuStatistics());
}
TypeHelper.SetFieldForAnnotation(producingOp, typeof(DataFlowContextAttribute), runtimeContext);
runtimeContexts.Put(producerOpNum, runtimeContext);
}
// Second pass: hook punctuation such that it gets forwarded
foreach (int producerOpNum in operatorBuildOrder)
{
String operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint;
if (Log.IsDebugEnabled)
{
Log.Debug("Handling signals for " + operatorPrettyPrint);
}
// determine consumers that receive punctuation
ICollection <int> consumingOperatorsWithPunctuation = new HashSet <int>();
foreach (LogicalChannelBinding binding in bindings)
{
if (!binding.LogicalChannel.OutputPort.HasPunctuation ||
binding.LogicalChannel.OutputPort.ProducingOpNum != producerOpNum)
{
continue;
}
consumingOperatorsWithPunctuation.Add(binding.LogicalChannel.ConsumingOpNum);
}
// hook up a listener for each
foreach (int consumerPunc in consumingOperatorsWithPunctuation)
{
EPDataFlowEmitter context = runtimeContexts.Get(consumerPunc);
if (context == null)
{
continue;
}
dataFlowSignalManager.AddSignalListener(
producerOpNum, new ProxyDataFlowSignalListener
{
ProcSignal = context.SubmitSignal
});
}
}
return(new DataflowStartDesc(statisticsProvider));
}
public static OperatorStatisticsProvider Realize(
DataflowDesc dataflow,
IDictionary<int, object> operators,
IList<LogicalChannelBinding> bindings,
DataFlowSignalManager dataFlowSignalManager,
EPDataFlowInstantiationOptions options,
AgentInstanceContext agentInstanceContext)
{
IDictionary<int, OperatorMetadataDescriptor> operatorMetadata = dataflow.OperatorMetadata;
// First pass: inject runtime context
IDictionary<int, EPDataFlowEmitter> runtimeContexts = new Dictionary<int, EPDataFlowEmitter>();
OperatorStatisticsProvider statisticsProvider = null;
if (options.IsOperatorStatistics) {
statisticsProvider = new OperatorStatisticsProvider(operatorMetadata);
}
foreach (int producerOpNum in dataflow.OperatorBuildOrder) {
var operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint;
if (Log.IsDebugEnabled) {
Log.Debug("Generating runtime context for " + operatorPrettyPrint);
}
// determine the number of output streams
var producingOp = operators.Get(producerOpNum);
var numOutputStreams = operatorMetadata.Get(producerOpNum).NumOutputPorts;
var targets = GetOperatorConsumersPerStream(
numOutputStreams,
producerOpNum,
operators,
operatorMetadata,
bindings);
var runtimeContext = GenerateRuntimeContext(
agentInstanceContext,
dataflow,
options.DataFlowInstanceId,
producerOpNum,
operatorPrettyPrint,
dataFlowSignalManager,
targets,
options);
if (options.IsOperatorStatistics) {
runtimeContext = new EPDataFlowEmitterWrapperWStatistics(
runtimeContext,
producerOpNum,
statisticsProvider,
options.IsCpuStatistics);
}
TypeHelper.SetFieldForAnnotation(producingOp, typeof(DataFlowContextAttribute), runtimeContext);
runtimeContexts.Put(producerOpNum, runtimeContext);
}
// Second pass: hook punctuation such that it gets forwarded
foreach (int producerOpNum in dataflow.OperatorBuildOrder) {
var operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint;
if (Log.IsDebugEnabled) {
Log.Debug("Handling signals for " + operatorPrettyPrint);
}
// determine consumers that receive punctuation
ISet<int> consumingOperatorsWithPunctuation = new HashSet<int>();
foreach (var binding in bindings) {
if (!binding.LogicalChannel.OutputPort.HasPunctuation ||
binding.LogicalChannel.OutputPort.ProducingOpNum != producerOpNum) {
continue;
}
consumingOperatorsWithPunctuation.Add(binding.LogicalChannel.ConsumingOpNum);
}
// hook up a listener for each
foreach (var consumerPunc in consumingOperatorsWithPunctuation) {
var context = runtimeContexts.Get(consumerPunc);
if (context == null) {
continue;
}
dataFlowSignalManager.AddSignalListener(
producerOpNum,
new ProxyDataFlowSignalListener {
ProcProcessSignal = signal => context.SubmitSignal(signal)
});
}
}
return statisticsProvider;
}
private static EPDataFlowEmitter GenerateRuntimeContext(
AgentInstanceContext agentInstanceContext,
DataflowDesc dataflow,
string instanceId,
int producerOpNum,
string operatorPrettyPrint,
DataFlowSignalManager dataFlowSignalManager,
IList<ObjectBindingPair>[] targetsPerStream,
EPDataFlowInstantiationOptions options)
{
// handle no targets
if (targetsPerStream == null) {
return new EPDataFlowEmitterNoTarget(producerOpNum, dataFlowSignalManager);
}
var dataflowName = dataflow.DataflowName;
var classpathImportService = agentInstanceContext.ImportServiceRuntime;
// handle single-stream case
if (targetsPerStream.Length == 1) {
var targets = targetsPerStream[0];
// handle single-stream single target case
if (targets.Count == 1) {
var target = targets[0];
return GetSubmitHandler(
agentInstanceContext,
dataflow.DataflowName,
instanceId,
producerOpNum,
operatorPrettyPrint,
dataFlowSignalManager,
target,
options.ExceptionHandler,
classpathImportService);
}
var handlers = new SubmitHandler[targets.Count];
for (var i = 0; i < handlers.Length; i++) {
handlers[i] = GetSubmitHandler(
agentInstanceContext,
dataflowName,
instanceId,
producerOpNum,
operatorPrettyPrint,
dataFlowSignalManager,
targets[i],
options.ExceptionHandler,
classpathImportService);
}
return new EPDataFlowEmitter1StreamNTarget(producerOpNum, dataFlowSignalManager, handlers);
}
// handle multi-stream case
var handlersPerStream = new SubmitHandler[targetsPerStream.Length][];
for (var streamNum = 0; streamNum < targetsPerStream.Length; streamNum++) {
var handlers = new SubmitHandler[targetsPerStream[streamNum].Count];
handlersPerStream[streamNum] = handlers;
for (var i = 0; i < handlers.Length; i++) {
handlers[i] = GetSubmitHandler(
agentInstanceContext,
dataflowName,
instanceId,
producerOpNum,
operatorPrettyPrint,
dataFlowSignalManager,
targetsPerStream[streamNum][i],
options.ExceptionHandler,
classpathImportService);
}
}
return new EPDataFlowEmitterNStreamNTarget(producerOpNum, dataFlowSignalManager, handlersPerStream);
}
public static EPDataFlowInstance Instantiate(
IContainer container,
int agentInstanceId,
DataflowDesc dataflow,
EPDataFlowInstantiationOptions options)
{
var statementContext = dataflow.StatementContext;
// allocate agent instance context
var @lock = statementContext.StatementAgentInstanceLockFactory.GetStatementLock(
statementContext.StatementName,
statementContext.Annotations,
statementContext.IsStatelessSelect,
statementContext.StatementType);
var handle = new EPStatementAgentInstanceHandle(statementContext.EpStatementHandle, agentInstanceId, @lock);
var auditProvider = statementContext.StatementInformationals.AuditProvider;
var instrumentationProvider = statementContext.StatementInformationals.InstrumentationProvider;
var agentInstanceContext = new AgentInstanceContext(statementContext, handle, null, null, auditProvider, instrumentationProvider);
// assure variables
statementContext.VariableManagementService.SetLocalVersion();
// instantiate operators
var operators = InstantiateOperators(container, agentInstanceContext, options, dataflow);
// determine binding of each channel to input methods (ports)
IList<LogicalChannelBinding> operatorChannelBindings = new List<LogicalChannelBinding>();
foreach (var channel in dataflow.LogicalChannels) {
var targetClass = operators.Get(channel.ConsumingOpNum).GetType();
var consumingMethod = FindMatchingMethod(channel.ConsumingOpPrettyPrint, targetClass, channel, false);
LogicalChannelBindingMethodDesc onSignalMethod = null;
if (channel.OutputPort.HasPunctuation) {
onSignalMethod = FindMatchingMethod(channel.ConsumingOpPrettyPrint, targetClass, channel, true);
}
operatorChannelBindings.Add(new LogicalChannelBinding(channel, consumingMethod, onSignalMethod));
}
// obtain realization
var dataFlowSignalManager = new DataFlowSignalManager();
var statistics = DataflowInstantiatorHelper.Realize(
dataflow,
operators,
operatorChannelBindings,
dataFlowSignalManager,
options,
agentInstanceContext);
// For each GraphSource add runnable
IList<GraphSourceRunnable> sourceRunnables = new List<GraphSourceRunnable>();
var audit = AuditEnum.DATAFLOW_SOURCE.GetAudit(statementContext.Annotations) != null;
foreach (var operatorEntry in operators) {
if (!(operatorEntry.Value is DataFlowSourceOperator)) {
continue;
}
var meta = dataflow.OperatorMetadata.Get(operatorEntry.Key);
var graphSource = (DataFlowSourceOperator) operatorEntry.Value;
var runnable = new GraphSourceRunnable(
agentInstanceContext,
graphSource,
dataflow.DataflowName,
options.DataFlowInstanceId,
meta.OperatorName,
operatorEntry.Key,
meta.OperatorPrettyPrint,
options.ExceptionHandler,
audit);
sourceRunnables.Add(runnable);
dataFlowSignalManager.AddSignalListener(operatorEntry.Key, runnable);
}
return new EPDataFlowInstanceImpl(
options.DataFlowInstanceUserObject,
options.DataFlowInstanceId,
statistics,
operators,
sourceRunnables,
dataflow,
agentInstanceContext,
statistics,
options.ParametersURIs);
}
