internal void SetCurrent(ref MessageRpc rpc) { Transaction current = rpc.Transaction.Current; if (current == null) { DiagnosticUtility.FailFast("we should never get here with a requestTransaction null"); } lock (this.mutex) { if (this.current == null) { this.current = current; } else if (this.current != current) { this.waiting = current; this.paused = rpc.Pause(); } else { rpc.Transaction.Current = this.current; } } }
// ........................................................................................................ internal void SetCurrent(ref MessageRpc rpc) { Transaction requestTransaction = rpc.Transaction.Current; if (!(requestTransaction != null)) { // tx processing requires failfast when state is inconsistent DiagnosticUtility.FailFast("we should never get here with a requestTransaction null"); } lock (this.mutex) { if (this.current == null) { this.current = requestTransaction; } else if (this.current != requestTransaction) { this.waiting = requestTransaction; this.paused = rpc.Pause(); } else { rpc.Transaction.Current = this.current; //rpc.Transaction.Current should get the dependent clone } } }
private void SynchronizationContextEndCallback(object state) { IResumeMessageRpc resume = (IResumeMessageRpc)state; this.ResumeProcessing(resume); this.GetSyncContext(resume.GetMessageInstanceContext()).OperationCompleted(); }
public AcknowledgementCompleteAsyncResult( ReceiveContext receiveContext, TimeSpan timeout, ref MessageRpc rpc, Transaction transaction, AsyncCallback callback, object state) : base(callback, state) { this.receiveContext = receiveContext; this.currentTransaction = transaction; this.channelHandler = rpc.channelHandler; this.resumableRPC = rpc.Pause(); bool completeThrew = true; try { bool completed = this.Complete(timeout); completeThrew = false; if (completed) { this.resumableRPC = null; rpc.UnPause(); this.Complete(true); } } finally { if (completeThrew) { rpc.UnPause(); } } }
private void ResumeProcessing(IResumeMessageRpc resume) { bool flag; resume.Resume(out flag); if (flag) { string message = System.ServiceModel.SR.GetString("SFxMultipleCallbackFromSynchronizationContext", new object[] { this.context.GetType().ToString() }); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(message)); } }
// static void OnFinalizeCorrelationCompletedCallback(IAsyncResult result) // { // if (result.CompletedSynchronously) // { // return; // } // IResumeMessageRpc resume = result.AsyncState as IResumeMessageRpc; // if (resume == null) // { // throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.Format(SR.SFxInvalidAsyncResultState0)); // } // resume.Resume(result); // } static void OnReplyCompletedCallback(Task result, object state) { IResumeMessageRpc resume = state as IResumeMessageRpc; if (resume == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.SFxInvalidAsyncResultState0); } resume.Resume(result); }
private void SynchronizationContextEndCallback(object state) { IResumeMessageRpc resume = (IResumeMessageRpc)state; ResumeProcessing(resume); SynchronizationContext syncContext = GetSyncContext(resume.GetMessageInstanceContext()); Fx.Assert(syncContext != null, "syncContext is null !?"); syncContext.OperationCompleted(); }
private void ResumeProcessing(IResumeMessageRpc resume) { bool alreadyResumedNoLock; resume.Resume(out alreadyResumedNoLock); if (alreadyResumedNoLock) { string text = SR.Format(SR.SFxMultipleCallbackFromSynchronizationContext, _context.GetType().ToString()); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(text)); } }
private static void InvokeCallback(IAsyncResult result) { if (!result.CompletedSynchronously) { IResumeMessageRpc asyncState = result.AsyncState as IResumeMessageRpc; if (asyncState == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.ServiceModel.SR.GetString("SFxInvalidAsyncResultState0")); } asyncState.SignalConditionalResume(result); } }
static void InvokeCallback(IAsyncResult result) { if (result.CompletedSynchronously) { return; } IResumeMessageRpc resume = result.AsyncState as IResumeMessageRpc; if (resume == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.SFxInvalidAsyncResultState0); } resume.SignalConditionalResume(result); }
private static void OnReplyCompletedCallback(IAsyncResult result) { if (result.CompletedSynchronously) { return; } IResumeMessageRpc resume = result.AsyncState as IResumeMessageRpc; if (resume == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRServiceModel.SFxInvalidAsyncResultState0); } resume.Resume(result); }
private void BeginReply(ref MessageRpc rpc) { bool success = false; try { IResumeMessageRpc resume = rpc.Pause(); rpc.AsyncResult = rpc.RequestContext.BeginReply(rpc.Reply, rpc.ReplyTimeoutHelper.RemainingTime(), s_onReplyCompleted, resume); success = true; if (rpc.AsyncResult.CompletedSynchronously) { rpc.UnPause(); } } catch (CommunicationException e) { _error.HandleError(e); } catch (TimeoutException e) { _error.HandleError(e); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } if (!_error.HandleError(e)) { rpc.RequestContextThrewOnReply = true; rpc.CanSendReply = false; } } finally { if (!success) { rpc.UnPause(); } } }
internal void InvokeBegin(ref MessageRpc rpc) { if (rpc.Error == null) { object target = rpc.Instance; this.DeserializeInputs(ref rpc); this.InspectInputs(ref rpc); ValidateMustUnderstand(ref rpc); IAsyncResult result; bool isBeginSuccessful = false; IResumeMessageRpc resumeRpc = rpc.Pause(); try { result = Invoker.InvokeBegin(target, rpc.InputParameters, invokeCallback, resumeRpc); isBeginSuccessful = true; } finally { if (!isBeginSuccessful) { rpc.UnPause(); } } if (result == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("IOperationInvoker.BeginDispatch"), rpc.Request); } if (result.CompletedSynchronously) { // if the async call completed synchronously, then the responsibility to call // ProcessMessage{6,7,Cleanup} still remains on this thread rpc.UnPause(); rpc.AsyncResult = result; } } }
private void BindCore(ref MessageRpc rpc, bool startOperation) { SynchronizationContext syncContext = GetSyncContext(rpc.InstanceContext); if (syncContext != null) { IResumeMessageRpc resume = rpc.Pause(); if (startOperation) { syncContext.OperationStarted(); syncContext.Post(ThreadAffinityStartCallbackDelegate, resume); } else { syncContext.Post(ThreadAffinityEndCallbackDelegate, resume); } } else if (rpc.SwitchedThreads) { IResumeMessageRpc resume = rpc.Pause(); ActionItem.Schedule(ThreadBehavior.CleanThreadCallbackDelegate, resume); } }
internal void InvokeBegin(ref MessageRpc rpc) { if (rpc.Error == null) { try { this.InitializeCallContext(ref rpc); object instance = rpc.Instance; this.DeserializeInputs(ref rpc); this.InspectInputs(ref rpc); this.ValidateMustUnderstand(ref rpc); IAsyncResult result = null; IDisposable impersonationContext = null; IPrincipal originalPrincipal = null; bool isThreadPrincipalSet = false; bool flag2 = this.Parent.IsConcurrent(ref rpc); try { if (this.parent.SecurityImpersonation != null) { this.parent.SecurityImpersonation.StartImpersonation(ref rpc, out impersonationContext, out originalPrincipal, out isThreadPrincipalSet); } IManualConcurrencyOperationInvoker invoker = this.Invoker as IManualConcurrencyOperationInvoker; if (this.isSynchronous) { if ((invoker != null) && flag2) { if (this.bufferedReceiveEnabled) { rpc.OperationContext.IncomingMessageProperties.Add(BufferedReceiveMessageProperty.Name, new BufferedReceiveMessageProperty(ref rpc)); } rpc.ReturnParameter = invoker.Invoke(instance, rpc.InputParameters, rpc.InvokeNotification, out rpc.OutputParameters); } else { rpc.ReturnParameter = this.Invoker.Invoke(instance, rpc.InputParameters, out rpc.OutputParameters); } } else { bool flag3 = false; if (((invoker != null) && flag2) && this.bufferedReceiveEnabled) { rpc.OperationContext.IncomingMessageProperties.Add(BufferedReceiveMessageProperty.Name, new BufferedReceiveMessageProperty(ref rpc)); } IResumeMessageRpc state = rpc.Pause(); try { if ((invoker != null) && flag2) { result = invoker.InvokeBegin(instance, rpc.InputParameters, rpc.InvokeNotification, invokeCallback, state); } else { result = this.Invoker.InvokeBegin(instance, rpc.InputParameters, invokeCallback, state); } flag3 = true; } finally { if (!flag3) { rpc.UnPause(); } } } } finally { try { if (this.parent.SecurityImpersonation != null) { this.parent.SecurityImpersonation.StopImpersonation(ref rpc, impersonationContext, originalPrincipal, isThreadPrincipalSet); } } catch { string message = null; try { message = System.ServiceModel.SR.GetString("SFxRevertImpersonationFailed0"); } finally { DiagnosticUtility.FailFast(message); } } } if (this.isSynchronous) { this.InspectOutputs(ref rpc); this.SerializeOutputs(ref rpc); } else { if (result == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("IOperationInvoker.BeginDispatch"), rpc.Request); } if (result.CompletedSynchronously) { rpc.UnPause(); rpc.AsyncResult = result; } } } catch { throw; } finally { this.UninitializeCallContext(ref rpc); } } }
internal MessageRpcWaiter(IResumeMessageRpc resume) { this.resume = resume; }
internal void InvokeBegin(ref MessageRpc rpc) { if (rpc.Error == null) { try { this.InitializeCallContext(ref rpc); object target = rpc.Instance; this.DeserializeInputs(ref rpc); this.InspectInputs(ref rpc); ValidateMustUnderstand(ref rpc); IAsyncResult result = null; IDisposable impersonationContext = null; IPrincipal originalPrincipal = null; bool isThreadPrincipalSet = false; bool isConcurrent = this.Parent.IsConcurrent(ref rpc); try { if (this.parent.RequireClaimsPrincipalOnOperationContext) { SetClaimsPrincipalToOperationContext(rpc); } if (this.parent.SecurityImpersonation != null) { this.parent.SecurityImpersonation.StartImpersonation(ref rpc, out impersonationContext, out originalPrincipal, out isThreadPrincipalSet); } IManualConcurrencyOperationInvoker manualInvoker = this.Invoker as IManualConcurrencyOperationInvoker; if (DS.OperationInvokerIsEnabled()) { DS.InvokeOperationStart(this.Invoker.GetType(), Stopwatch.GetTimestamp()); } if (this.isSynchronous) { if (manualInvoker != null && isConcurrent) { if (this.bufferedReceiveEnabled) { rpc.OperationContext.IncomingMessageProperties.Add( BufferedReceiveMessageProperty.Name, new BufferedReceiveMessageProperty(ref rpc)); } rpc.ReturnParameter = manualInvoker.Invoke(target, rpc.InputParameters, rpc.InvokeNotification, out rpc.OutputParameters); } else { rpc.ReturnParameter = this.Invoker.Invoke(target, rpc.InputParameters, out rpc.OutputParameters); } } else { bool isBeginSuccessful = false; if (manualInvoker != null && isConcurrent && this.bufferedReceiveEnabled) { // This will modify the rpc, it has to be done before rpc.Pause // since IResumeMessageRpc implementation keeps reference of rpc. // This is to ensure consistent rpc whether or not InvokeBegin completed // synchronously or asynchronously. rpc.OperationContext.IncomingMessageProperties.Add( BufferedReceiveMessageProperty.Name, new BufferedReceiveMessageProperty(ref rpc)); } IResumeMessageRpc resumeRpc = rpc.Pause(); try { if (manualInvoker != null && isConcurrent) { result = manualInvoker.InvokeBegin(target, rpc.InputParameters, rpc.InvokeNotification, invokeCallback, resumeRpc); } else { result = this.Invoker.InvokeBegin(target, rpc.InputParameters, invokeCallback, resumeRpc); } isBeginSuccessful = true; // if the call above actually went async, then responsibility to call // ProcessMessage{6,7,Cleanup} has been transferred to InvokeCallback } finally { if (!isBeginSuccessful) { rpc.UnPause(); } } } } finally { try { if (this.parent.SecurityImpersonation != null) { this.parent.SecurityImpersonation.StopImpersonation(ref rpc, impersonationContext, originalPrincipal, isThreadPrincipalSet); } } #pragma warning suppress 56500 // covered by FxCOP catch { string message = null; try { message = SR.GetString(SR.SFxRevertImpersonationFailed0); } finally { DiagnosticUtility.FailFast(message); } } if (this.isSynchronous && DS.OperationInvokerIsEnabled()) { DS.InvokeOperationStop(Stopwatch.GetTimestamp()); } } if (this.isSynchronous) { this.InspectOutputs(ref rpc); this.SerializeOutputs(ref rpc); } else { if (result == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("IOperationInvoker.BeginDispatch"), rpc.Request); } if (result.CompletedSynchronously) { // if the async call completed synchronously, then the responsibility to call // ProcessMessage{6,7,Cleanup} still remains on this thread rpc.UnPause(); rpc.AsyncResult = result; } } } #pragma warning suppress 56500 // covered by FxCOP catch { throw; } // Make sure user Exception filters are not impersonated. finally { this.UninitializeCallContext(ref rpc); } } }
internal MessageRpcWaiter(IResumeMessageRpc resume) { _resume = resume; }