// This happens out-of-band of ReceiveAsyncResult. // When transaction was aborted, we best-effort abandon the context. void OnTransactionComplete(object sender, TransactionEventArgs e) { if (e.Transaction.TransactionInformation.Status != TransactionStatus.Committed) { BufferedReceiveManager.AbandonReceiveContext(this.context.receiveContext); } }
private bool ProcessReply() { bool flag = false; this.workflowInstance.ReleaseContext(this); this.RemovePendingOperation(); if (this.CurrentState == State.BookmarkResumption) { this.CurrentState = State.ResultReceived; } else if (this.CurrentState == State.WaitForResult) { this.CurrentState = State.Completed; flag = true; } if (flag) { if (this.pendingException == null) { return(this.ProcessReceiveContext()); } BufferedReceiveManager.AbandonReceiveContext(this.receiveContext); } return(flag); }
bool ProcessReply() { bool completed = false; this.workflowInstance.ReleaseContext(this); this.RemovePendingOperation(); if (this.CurrentState == State.BookmarkResumption) //We are still in Bookmark Resume { this.CurrentState = State.ResultReceived; //HandleEndResumeBookmark will take care of Completing AsyncResult. } else if (this.CurrentState == State.WaitForResult) //We already finished the bookmarkOperation; Now have to signal the AsynResult. { this.CurrentState = State.Completed; completed = true; } // we are not really completed until the ReceiveContext finishes its work if (completed) { if (this.pendingException == null) { completed = ProcessReceiveContext(); } else { // if there's a pendingException, we let the RC abandon async so there's no need // to affect the completed status BufferedReceiveManager.AbandonReceiveContext(this.receiveContext); } } return(completed); }
private static bool HandleEndResumeBookmark(IAsyncResult result) { WorkflowOperationContext asyncState = (WorkflowOperationContext)result.AsyncState; bool flag = false; bool flag2 = true; try { if (asyncState.workflowInstance.EndResumeProtocolBookmark(result) != BookmarkResumptionResult.Success) { asyncState.OperationContext.Host.RaiseUnknownMessageReceived(asyncState.OperationContext.IncomingMessage); if ((asyncState.workflowInstance.BufferedReceiveManager != null) && asyncState.workflowInstance.BufferedReceiveManager.BufferReceive(asyncState.OperationContext, asyncState.receiveContext, asyncState.bookmark.Name, BufferedReceiveState.WaitingOnBookmark, false)) { if (System.ServiceModel.Activities.TD.BufferOutOfOrderMessageNoBookmarkIsEnabled()) { System.ServiceModel.Activities.TD.BufferOutOfOrderMessageNoBookmark(asyncState.workflowInstance.Id.ToString(), asyncState.bookmark.Name); } flag2 = false; } throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new FaultException(OperationExecutionFault.CreateOperationNotAvailableFault(asyncState.workflowInstance.Id, asyncState.bookmark.Name))); } lock (asyncState.thisLock) { if (asyncState.CurrentState == State.ResultReceived) { asyncState.CurrentState = State.Completed; if (asyncState.pendingException != null) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(asyncState.pendingException); } flag = true; } else { asyncState.CurrentState = State.WaitForResult; flag = false; } if (flag) { flag = asyncState.ProcessReceiveContext(); } flag2 = false; } } finally { if (flag2) { BufferedReceiveManager.AbandonReceiveContext(asyncState.receiveContext); } asyncState.RemovePendingOperation(); } return(flag); }
static bool HandleEndResumeBookmark(IAsyncResult result) { WorkflowOperationContext thisPtr = (WorkflowOperationContext)result.AsyncState; bool completed = false; bool shouldAbandon = true; try { BookmarkResumptionResult resumptionResult = thisPtr.workflowInstance.EndResumeProtocolBookmark(result); if (resumptionResult != BookmarkResumptionResult.Success) { // Raise UnkownMessageReceivedEvent when we fail to resume bookmark thisPtr.OperationContext.Host.RaiseUnknownMessageReceived(thisPtr.OperationContext.IncomingMessage); // Only delay-retry this operation once (and only if retries are supported). Future calls will ensure the bookmark is set. if (thisPtr.workflowInstance.BufferedReceiveManager != null) { bool bufferSuccess = thisPtr.workflowInstance.BufferedReceiveManager.BufferReceive( thisPtr.OperationContext, thisPtr.receiveContext, thisPtr.bookmark.Name, BufferedReceiveState.WaitingOnBookmark, false); if (bufferSuccess) { if (TD.BufferOutOfOrderMessageNoBookmarkIsEnabled()) { TD.BufferOutOfOrderMessageNoBookmark(thisPtr.eventTraceActivity, thisPtr.workflowInstance.Id.ToString(), thisPtr.bookmark.Name); } shouldAbandon = false; } } // The throw exception is intentional whether or not BufferedReceiveManager is set. // This is to allow exception to bubble up the stack to WCF to cleanup various state (like Transaction). // This is queue scenario and as far as the client is concerned, the client will not see any exception. throw FxTrace.Exception.AsError(new FaultException(OperationExecutionFault.CreateOperationNotAvailableFault(thisPtr.workflowInstance.Id, thisPtr.bookmark.Name))); } lock (thisPtr.thisLock) { if (thisPtr.CurrentState == State.ResultReceived) { thisPtr.CurrentState = State.Completed; if (thisPtr.pendingException != null) { throw FxTrace.Exception.AsError(thisPtr.pendingException); } completed = true; } else { thisPtr.CurrentState = State.WaitForResult; completed = false; } // we are not really completed until the ReceiveContext finishes its work if (completed) { completed = thisPtr.ProcessReceiveContext(); } shouldAbandon = false; } } finally { if (shouldAbandon) { BufferedReceiveManager.AbandonReceiveContext(thisPtr.receiveContext); } thisPtr.RemovePendingOperation(); } return(completed); }