public WorkItemWithHistory AddWorkItemMessage(TaskProgressCallbackMessage value,
ObservableCollection <WorkItemWithHistory> parents, int inRouteIndex)
{
WorkItemId rootId = value.RouteToChild[inRouteIndex];
WorkItemWithHistory parent = parents.FirstOrDefault(workItem => workItem.Id == rootId.Id);
if (parent == null)
{
parent = new WorkItemWithHistory
{
Id = rootId.Id,
Name = rootId.Name,
WorkItemType = rootId.WorkItemType
};
parents.Add(parent);
}
if (inRouteIndex != value.RouteToChild.Count - 1)
{
return(AddWorkItemMessage(value, parent.Children, inRouteIndex + 1));
}
ProcessProgressMessage(value, parent);
return(parent);
}
private void UpdateParentDepthLevelAndInsert(WorkItemWithHistory parent, TaskProgressCallbackMessage value)
{
if ((value.MessageType == WorkItemStatus.Closed ||
value.MessageType == WorkItemStatus.Canceled ||
value.MessageType == WorkItemStatus.Faulted) &&
parent.CrtDepthLevel > 0)
{
parent.CrtDepthLevel--;
}
CallbackMessageContent currentCallbackMessage = GetCallbackMessageContent(value, parent);
int index;
for (index = parent.MessageHistory.Count - 1; index >= 0; index--)
{
if (parent.MessageHistory[index].RecordNumber < currentCallbackMessage.RecordNumber)
{
break;
}
}
parent.MessageHistory.Insert(index + 1, currentCallbackMessage);
if (value.MessageType == WorkItemStatus.Executing)
{
parent.CrtDepthLevel++;
}
}
public void WorkItemLogCallback(TaskProgressCallbackMessage callbackMessage, long messageIndex)
{
CheckMessageIndex(
() =>
{
lock (_sinkRoot)
{
WorkItemWithHistory updatedItem = AddWorkItemMessage(callbackMessage, PendingWorkItems, 0);
NotifyProgress(new WorkItemUpdateData
{
WorkItemWithHistory = new WorkItemWithHistory
{
Name = updatedItem.Name,
Id = updatedItem.Id,
WorkItemType = updatedItem.WorkItemType,
CrtDepthLevel = updatedItem.CrtDepthLevel,
MessageHistory = new ObservableCollection <CallbackMessageContent>
(updatedItem.MessageHistory)
},
ProgressCallbackMessage = callbackMessage
});
}
},
messageIndex
);
}
private void PushProgressMessage(TaskProgressCallbackMessage progressCallbackMessage, Guid workflowInstanceId)
{
_activeWorkItemsLogs.PushMessage(workflowInstanceId, progressCallbackMessage, _messageIndex++);
if (ProgressObserver != null)
{
ProgressObserver.WorkItemLogCallback(progressCallbackMessage, _messageIndex);
}
}
private void ProcessFaultPropagationRecord(FaultPropagationRecord faultPropagationRecord)
{
string pendingFaultedKey = FautedMessageKey(faultPropagationRecord.FaultSource);
if (_pendingFaultedMessages.ContainsKey(pendingFaultedKey))
{
TaskProgressCallbackMessage progressCallbackMessage = _pendingFaultedMessages[pendingFaultedKey];
_pendingFaultedMessages.Remove(pendingFaultedKey);
progressCallbackMessage.Message = _formatError(faultPropagationRecord.Fault);
PushProgressMessage(progressCallbackMessage, faultPropagationRecord.InstanceId);
}
}
private CallbackMessageContent GetCallbackMessageContent(TaskProgressCallbackMessage value,
WorkItemWithHistory parent)
{
return(new CallbackMessageContent
{
RecordNumber = value.RecordNumber,
MessageType = value.MessageType,
ActivityName = value.ActivityName,
Message = value.Message,
TimeStamp = value.TimeStamp,
DepthLevel = parent.CrtDepthLevel
});
}
private TaskProgressCallbackMessage GetLocalTaskProgressCallbackMessage(TaskProgressCallbackMessage callbackMessage)
{
if (_cloneMessages == false)
{
return(callbackMessage);
}
using (MemoryStream memoryStream = new MemoryStream())
{
TaskProgressCallbackMessageSerializer.WriteObject(memoryStream, callbackMessage);
memoryStream.Seek(0, SeekOrigin.Begin);
return((TaskProgressCallbackMessage)TaskProgressCallbackMessageSerializer.ReadObject(memoryStream));
}
}
public void PushMessage(Guid workflowInstanceId, TaskProgressCallbackMessage message, long messageIndex)
{
WorkItemWithHistory rootWorkItem = GetRootWorkItemForWorkflowInstance(workflowInstanceId);
message.RouteToChild = rootWorkItem.RouteFromParentToChild(message.RouteToChild[0].Id)
.ConvertAll(workItemWithChildren =>
new WorkItemId
{
Id = workItemWithChildren.Id,
Name = workItemWithChildren.Name,
WorkItemType = workItemWithChildren.WorkItemType
});
_workItemProgressObserver.WorkItemLogCallback(message, messageIndex);
}
private void ProcessActivityStateRecord(ActivityStateRecord activityStateRecord)
{
if (activityStateRecord.Arguments.ContainsKey(CustomProgressTrackingDataKey.Target))
{
TaskProgressCallbackMessage progressCallbackMessage = ToProgressCallbackMessage(activityStateRecord);
if (activityStateRecord.State == "Faulted")
{
//will be sent by ProcessFaultPropagationRecord when the fault is available
_pendingFaultedMessages.Add(FautedMessageKey(activityStateRecord.Activity), progressCallbackMessage);
return;
}
Guid workflowInstanceId = activityStateRecord.InstanceId;
PushProgressMessage(progressCallbackMessage, workflowInstanceId);
}
}
private void ProcessProgressMessage(TaskProgressCallbackMessage value, WorkItemWithHistory parent)
{
if (value.MessageType == WorkItemStatus.Received)
{
return;
}
if (value.MessageType == WorkItemStatus.Canceled)
{
CallbackMessageContent previousMessage = parent.GetLastUpdateMessage();
if (previousMessage != null && previousMessage.MessageType == WorkItemStatus.Faulted)
{
return;
}
}
UpdateParentDepthLevelAndInsert(parent, value);
}
public void WorkItemLogCallback(TaskProgressCallbackMessage callbackMessage, long messageIndex)
{
if (!_dispatcher.CheckAccess())
{
_dispatcher.Invoke((Action <TaskProgressCallbackMessage, long>)WorkItemLogCallback,
DispatcherPriority.Normal, new object[] { callbackMessage, messageIndex });
}
else
{
TaskProgressCallbackMessage localCallbackMessage = GetLocalTaskProgressCallbackMessage(callbackMessage);
lock (synckRoot)
{
if (_progressMonitor == null)
{
unprocessedMessageQueue.Enqueue(
() => _progressMonitor.WorkItemLogCallback(localCallbackMessage, messageIndex));
}
else
{
_progressMonitor.WorkItemLogCallback(localCallbackMessage, messageIndex);
}
}
}
}
private void ProcessCustomTrackingRecord(CustomTrackingRecord customTrackingRecord)
{
if (customTrackingRecord.Name == WorkItemStatus.Received)
{
var lookupTree = customTrackingRecord.GetData <WorkItemWithHistory>(CustomProgressTrackingDataKey.LookupTree);
_activeWorkItemsLogs.RegisterWorkflowInstanceWithLookupTree(
customTrackingRecord.InstanceId, lookupTree, _messageIndex++);
if (ProgressObserver != null)
{
ProgressObserver.RegisterWorkItemsWithHistoryTree(lookupTree, _messageIndex);
}
}
else
{
TaskProgressCallbackMessage progressCallbackMessage = ToProgressCallbackMessage(customTrackingRecord);
_activeWorkItemsLogs.PushMessage(customTrackingRecord.InstanceId, progressCallbackMessage, _messageIndex++);
if (ProgressObserver != null)
{
ProgressObserver.WorkItemLogCallback(progressCallbackMessage, _messageIndex);
}
}
}
public void WorkItemLogCallback(TaskProgressCallbackMessage callbackMessage, long messageIndex)
{
InvokeCallback(() => _serviceCallbackProxy.WorkItemLogCallback(callbackMessage, messageIndex));
}
