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)); }