public IEnumerable <IDataflowMessage <TOut> > TransformMany(IDataflowMessage <TIn> item)
{
var result = m_Decorated.TransformMany(item).Select(c => new DefaultDataflowMessage <TOut>(c.Data).WithTitle(Title));
//Send(new WorkloadStatisticsContext(this.TaskGuid, m_nms, m_InMsgFunc(), m_OutMsgFunc(), GetBoundedCapacity(), Title));
return(result);
}
public virtual void AddChildMessage(IDataflowMessage msg)
{
//Set this as one of the parents for the specified message
msg.AddParentMessage(this);
//Add to the children
}
public IEnumerable <IDataflowMessage <TOut> > TransformMany(IDataflowMessage <TIn> item)
{
var result = m_Decorated.TransformMany(item);
Interlocked.Increment(ref NumProcessedMessages);
return(result);
}
public IEnumerable <IDataflowMessage <TOut> > TransformMany(IDataflowMessage <TIn> item)
{
try
{
if (item.IsBroken)
{
// Kind of unexpected, as those guys should usually be filtered
return(new List <IDataflowMessage <TOut> >
{
new BrokenDataflowMessage <TOut>(null, item.Data)
});
}
var result = m_Decorated.TransformMany(item.Data).Select(c => new DefaultDataflowMessage <TOut>(c).WithTitle(Title));
return(result);
}
catch (DataflowNetworkRecoverableErrorException recoverableError)
{
return(new List <IDataflowMessage <TOut> >
{
new BrokenDataflowMessage <TOut>(recoverableError, item.Data)
});
}
catch (DataflowNetworkUnrecoverableErrorException unrecoverableError)
{
// bring the network down.
m_LogAgent.LogFatal(DataflowNetworkConstituent.TransformMany, Title, unrecoverableError);
m_Cancel.CancelNetwork();
return(new List <IDataflowMessage <TOut> >
{
new BrokenDataflowMessage <TOut>(unrecoverableError, item.Data)
});
}
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn> item)
{
Interlocked.Increment(ref m_NumMessagesProcessed);
if (item.IsBroken)
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Transformation, Title, "Broken message propagates through network. Node: {0}, Message: {1}", Title, item.Title);
}
else
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Transformation, m_DecoratedTransformation.Title, "Transforming: {0}", item.Title);
}
IDataflowMessage <TOut> result = m_DecoratedTransformation.Transform(item);
if (result.IsBroken)
{
Interlocked.Increment(ref m_NumBrokenMsgs);
m_LogAgent.LogBrokenMessage(DataflowNetworkConstituent.Transformation, Title, result.Title, (IBrokenDataFlowMessage <TOut>)result);
}
else
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Transformation, m_DecoratedTransformation.Title, "Transformed: old: {0} new: {1}", item.Title, result.Title);
}
return(result);
}
public IEnumerable <IDataflowMessage <TOut> > TransformMany(IDataflowMessage <TIn> item)
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.TransformMany, m_Decorated.Title, "Transforming: {0}", item.Title);
var result = m_Decorated.TransformMany(item);
m_LogAgent.LogTrace(DataflowNetworkConstituent.TransformMany, m_Decorated.Title, "Transformed: {0}", item.Title);
return(result);
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn> item)
{
IDataflowMessage <TOut> result = m_DecoratedTransformation.Transform(item);
m_nms++;
Send(new WorkloadStatisticsContext(this.GroupGuid, this.TaskGuid, m_nms, m_InMsgFunc(), m_OutMsgFunc(), GetBoundedCapacity(), Title));
return(result);
}
public void Push(IDataflowMessage <TIn> item)
{
if (!item.IsBroken)
{
m_DecoratedTarget.Push(item);
m_nms++;
Send(new WorkloadStatisticsContext(this.GroupGuid, this.TaskGuid, m_nms, m_InMsgFunc(), -1, GetBoundedCapacity(), Title));
}
}
public void Push(IDataflowMessage <TIn> item)
{
Interlocked.Increment(ref NumProcessedMessages);
m_DecoratedTarget.Push(item);
if (item.IsBroken)
{
Interlocked.Increment(ref NumBrokenMessages);
}
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn>[] items)
{
IDataflowMessage <TOut> result = m_DecoratedTransformationBatched.Transform(items);
//var s = (Imis.Etl.Crosscutting.Logging.LogDecoratorTransformationBatched<TIn, TOut>)m_DecoratedTransformationBatched;
//var nms = s.NumMessagesSeen;
//var nms = -1;
m_nms = 0;
Send(new WorkloadStatisticsContext(this.GroupGuid, this.TaskGuid, m_nms, m_InMsgFunc(), m_OutMsgFunc(), GetBoundedCapacity(), Title));
return(result);
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn>[] items)
{
Interlocked.Increment(ref NumProcessedMessages);
IDataflowMessage <TOut> result = m_DecoratedTransformationBatched.Transform(items);
if (result.IsBroken)
{
Interlocked.Increment(ref NumBrokenMessages);
}
return(result);
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn> item)
{
Interlocked.Increment(ref m_NumMessagesProcessed);
IDataflowMessage <TOut> result = m_DecoratedTransformation.Transform(item);
if (result.IsEmpty)
{
Interlocked.Increment(ref m_NumEmptyMessages);
}
return(result);
}
public void Push(IDataflowMessage <TIn> item)
{
if (!item.IsBroken)
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Target, m_DecoratedTarget.Title, "Pushing: {0}", item.Title);
m_DecoratedTarget.Push(item);
m_LogAgent.LogTrace(DataflowNetworkConstituent.Target, m_DecoratedTarget.Title, "Pushed: {0}", item.Title);
}
else
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Target, Title, "Broken message propagated through network. Title: {0}", item.Title);
}
}
protected virtual IDataflowMessage <string> DecorateOutputMessage(IDataflowMessage <string> msg, Context context)
{
//Copy all the metadatas from the active input messages, and set the parent / child relations
foreach (var fromMsg in context.ActiveInputMessages)
{
//Set all the metadata from the message
msg.Metadata.SetAll(fromMsg.Metadata);
//Add as child message
fromMsg.AddChildMessage(msg);
}
return(msg);
}
public override void CloneFrom(IDataflowMessage fromMsg)
{
base.CloneFrom(fromMsg);
var fromBrokenMsg = fromMsg as IBrokenDataFlowMessage <TData>;
if (fromBrokenMsg == null)
{
return;
}
m_InputContent = fromBrokenMsg.InputContent;
m_BreakReason = fromBrokenMsg.BreakException;
}
public virtual void CloneFrom(IDataflowMessage fromMsg)
{
CreatedByTask = fromMsg.CreatedByTask;
Title = fromMsg.Title;
Errors = fromMsg.Errors;
IsBroken = fromMsg.IsBroken;
if (fromMsg.Metadata != null)
{
Metadata = fromMsg.Metadata.Clone();
}
SetData(fromMsg.Data);
}
public void Push(IDataflowMessage <TIn> item)
{
try
{
if (!item.IsBroken)
{
m_DecoratedTarget.Push(item.Data);
}
}
catch (DataflowNetworkUnrecoverableErrorException ex)
{
m_LogAgent.LogFatal(DataflowNetworkConstituent.Target, m_DecoratedTarget.Title, ex);
// Halt the entire dataflow network.
m_Cancel.CancelNetwork();
}
catch (DataflowNetworkRecoverableErrorException ex)
{
var broken = new BrokenDataflowMessage <TIn>(ex, item.Data);
m_LogAgent.LogBrokenMessage(DataflowNetworkConstituent.Target, Title, item.Title, broken);
}
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn>[] items)
{
Interlocked.Increment(ref m_NumMessagesProcessed);
long brokenMessageCnt = 0;
long totalMessageCnt = items.LongLength;
foreach (IDataflowMessage <TIn> item in items)
{
if (item.IsBroken)
{
brokenMessageCnt++;
m_LogAgent.LogTrace(DataflowNetworkConstituent.TransformationBatched, Title,
"Broken message propagates through network. Node: {0}, Message: {1}", Title,
item.Title);
}
else
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.TransformationBatched, m_DecoratedTransformation.Title,
"Transforming: {0}", item.Title);
}
}
m_LogAgent.LogTrace(DataflowNetworkConstituent.TransformationBatched, m_DecoratedTransformation.Title,
"Total message count: {0}, broken message count: {1}", totalMessageCnt, brokenMessageCnt);
IDataflowMessage <TOut> result = m_DecoratedTransformation.Transform(items);
if (result.IsBroken)
{
Interlocked.Increment(ref m_NumBrokenMsgs);
m_LogAgent.LogBrokenMessage(DataflowNetworkConstituent.Transformation, Title, result.Title, (IBrokenDataFlowMessage <TOut>)result);
}
else
{
m_LogAgent.LogTrace(DataflowNetworkConstituent.Transformation, m_DecoratedTransformation.Title, "Transformed with Batch-Size: old: {0} new: {1}", items.Length, result.Title);
}
return(result);
}
public IDataflowMessage <TOut> Transform(IDataflowMessage <TIn> item)
{
try
{
if (item.IsBroken)
{
var broken = (IBrokenDataFlowMessage <TIn>)item;
return(new BrokenDataflowMessage <TOut>(broken.BreakException, item.Data));
}
TOut result = m_DecoratedTransformation.Transform(item.Data);
return(new DefaultDataflowMessage <TOut>(result).WithTitle(Title));
}
catch (DataflowNetworkUnrecoverableErrorException ex)
{
m_LogAgent.LogFatal(DataflowNetworkConstituent.Transformation, m_DecoratedTransformation.Title, ex);
m_Cancel.CancelNetwork();
return(new BrokenDataflowMessage <TOut>(ex, item.Data));
}
catch (DataflowNetworkRecoverableErrorException ex)
{
return(new BrokenDataflowMessage <TOut>(ex, item.Data));
}
}
public virtual void AddParentMessage(IDataflowMessage msg)
{
//Add to the parents
}
