mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
807 lines
30 KiB
C#
807 lines
30 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Routing
|
|
{
|
|
using System;
|
|
using System.Configuration;
|
|
using System.Globalization;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Security;
|
|
using System.Transactions;
|
|
|
|
class ProcessMessagesAsyncResult<TContract> : TransactedAsyncResult
|
|
{
|
|
static AsyncCompletion clientOperationCallback = ClientOperationCallback;
|
|
static AsyncCompletion completeReceiveContextCallback = CompleteReceiveContextCallback;
|
|
static AsyncCompletion commitTransactionCallback = CommitTransactionCallback;
|
|
static AsyncCompletion channelCloseCallback = ChannelCloseCallback;
|
|
|
|
bool abortedRetry;
|
|
bool allCompletedSync = true;
|
|
RoutingChannelExtension channelExtension;
|
|
IRoutingClient client;
|
|
bool closeOutboundChannels;
|
|
int destinationIndex;
|
|
RoutingService service;
|
|
int sessionMessageIndex;
|
|
ProcessingState state = ProcessingState.Initial;
|
|
TimeoutHelper timeoutHelper;
|
|
|
|
public ProcessMessagesAsyncResult(Message message, RoutingService service, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.service = service;
|
|
this.channelExtension = service.ChannelExtension;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.timeoutHelper.RemainingTime(); //Start the timer
|
|
|
|
if (message == null)
|
|
{
|
|
//Null message means end of session, time to close everything
|
|
this.closeOutboundChannels = true;
|
|
this.state = ProcessingState.ClosingChannels;
|
|
}
|
|
else
|
|
{
|
|
this.closeOutboundChannels = false;
|
|
MessageRpc messageRpc = new MessageRpc(message, OperationContext.Current, this.channelExtension.ImpersonationRequired);
|
|
if (TD.RoutingServiceProcessingMessageIsEnabled())
|
|
{
|
|
TD.RoutingServiceProcessingMessage(messageRpc.EventTraceActivity, messageRpc.UniqueID, messageRpc.Message.Headers.Action, messageRpc.OperationContext.EndpointDispatcher.EndpointAddress.Uri.ToString(), (messageRpc.Transaction != null).ToString());
|
|
}
|
|
|
|
EndpointNameMessageFilter.Set(messageRpc.Message.Properties, this.channelExtension.EndpointName);
|
|
messageRpc.RouteToEndpoints<TContract>(this.service.RoutingConfig);
|
|
this.service.SessionMessages.Add(messageRpc);
|
|
|
|
this.sessionMessageIndex = this.service.SessionMessages.Count - 1;
|
|
if (this.sessionMessageIndex == 0)
|
|
{
|
|
//First message, do initialization stuff
|
|
this.state = ProcessingState.Initial;
|
|
}
|
|
else
|
|
{
|
|
this.state = ProcessingState.SendingSessionMessages;
|
|
}
|
|
}
|
|
this.ProcessWhileSync();
|
|
}
|
|
|
|
void ProcessWhileSync()
|
|
{
|
|
try
|
|
{
|
|
bool callAgain;
|
|
do
|
|
{
|
|
callAgain = this.ProcessNext();
|
|
} while (callAgain);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
this.Fault(e);
|
|
}
|
|
}
|
|
|
|
void ChangeState(ProcessingState newState)
|
|
{
|
|
this.sessionMessageIndex = 0;
|
|
this.destinationIndex = 0;
|
|
this.state = newState;
|
|
}
|
|
|
|
void ResetState()
|
|
{
|
|
this.service.ResetSession();
|
|
this.ChangeState(ProcessingState.Initial);
|
|
}
|
|
|
|
bool ProcessNext()
|
|
{
|
|
switch (this.state)
|
|
{
|
|
case ProcessingState.Initial:
|
|
{
|
|
this.service.CreateNewTransactionIfNeeded(this.service.SessionMessages[0]);
|
|
return this.DoneInitializing();
|
|
}
|
|
|
|
case ProcessingState.SendingSessionMessages:
|
|
{
|
|
return this.SendToCurrentClient();
|
|
}
|
|
|
|
case ProcessingState.ClosingChannels:
|
|
{
|
|
return this.CloseCurrentChannel();
|
|
}
|
|
|
|
case ProcessingState.CompletingReceiveContexts:
|
|
{
|
|
return this.CompleteCurrentReceiveContext();
|
|
}
|
|
|
|
case ProcessingState.CommittingTransaction:
|
|
{
|
|
return this.CommitTransaction();
|
|
}
|
|
|
|
case ProcessingState.Completing:
|
|
{
|
|
this.CompleteSelf(null);
|
|
return false;
|
|
}
|
|
|
|
default:
|
|
Fx.Assert("ProcessNext shouldn't be called in this state: " + this.state);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool SendToCurrentClient()
|
|
{
|
|
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
|
|
SendOperation sendOperation = messageRpc.Operations[this.destinationIndex];
|
|
if (sendOperation.Sent)
|
|
{
|
|
this.MoveToNextClientOperation(messageRpc.Operations.Count);
|
|
return true;
|
|
}
|
|
else if (!this.channelExtension.ReceiveContextEnabled &&
|
|
this.channelExtension.TransactedReceiveEnabled &&
|
|
sendOperation.HasAlternate)
|
|
{
|
|
// We can't do error handling for oneway Transactional unless there's RC.
|
|
throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR.ErrorHandlingNotSupportedTxNoRC(messageRpc.OperationContext.Channel.LocalAddress)));
|
|
}
|
|
|
|
RoutingEndpointTrait endpointTrait = sendOperation.CurrentEndpoint;
|
|
this.client = this.service.GetOrCreateClient<TContract>(endpointTrait, messageRpc.Impersonating);
|
|
try
|
|
{
|
|
// We always work on cloned message when there are backup endpoints to handle exception cases
|
|
Message message;
|
|
if (messageRpc.Operations.Count == 1 && sendOperation.AlternateEndpointCount == 0)
|
|
{
|
|
message = messageRpc.Message;
|
|
}
|
|
else
|
|
{
|
|
message = messageRpc.CreateBuffer().CreateMessage();
|
|
}
|
|
|
|
sendOperation.PrepareMessage(message);
|
|
IAsyncResult result;
|
|
|
|
if (TD.RoutingServiceTransmittingMessageIsEnabled())
|
|
{
|
|
TD.RoutingServiceTransmittingMessage(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), this.client.Key.ToString());
|
|
}
|
|
|
|
Transaction transaction = this.service.GetTransactionForSending(messageRpc);
|
|
using (this.PrepareTransactionalCall(transaction))
|
|
{
|
|
IDisposable impersonationContext = null;
|
|
try
|
|
{
|
|
//Perform the assignment in a finally block so it won't be interrupted asynchronously
|
|
try { }
|
|
finally
|
|
{
|
|
impersonationContext = messageRpc.PrepareCall();
|
|
}
|
|
|
|
result = this.client.BeginOperation(message, transaction, this.PrepareAsyncCompletion(clientOperationCallback), this);
|
|
}
|
|
finally
|
|
{
|
|
if (impersonationContext != null)
|
|
{
|
|
impersonationContext.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.CheckSyncContinue(result))
|
|
{
|
|
this.ClientOperationComplete(result);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (Fx.IsFatal(exception))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
//See if we can handle this Exception...
|
|
if (this.HandleClientOperationFailure(exception))
|
|
{
|
|
return true;
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
static bool ClientOperationCallback(IAsyncResult result)
|
|
{
|
|
ProcessMessagesAsyncResult<TContract> thisPtr = (ProcessMessagesAsyncResult<TContract>)result.AsyncState;
|
|
FxTrace.Trace.SetAndTraceTransfer(thisPtr.channelExtension.ActivityID, true);
|
|
try
|
|
{
|
|
try
|
|
{
|
|
thisPtr.allCompletedSync = false;
|
|
thisPtr.ClientOperationComplete(result);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (Fx.IsFatal(exception))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
//See if we can handle this Exception...
|
|
if (!thisPtr.HandleClientOperationFailure(exception))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
thisPtr.ProcessWhileSync();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
thisPtr.Fault(e);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ClientOperationComplete(IAsyncResult result)
|
|
{
|
|
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
|
|
SendOperation currentDest = messageRpc.Operations[this.destinationIndex];
|
|
|
|
this.client.EndOperation(result);
|
|
currentDest.TransmitSucceeded(this.service.GetTransactionForSending(messageRpc));
|
|
|
|
if (TD.RoutingServiceTransmitSucceededIsEnabled())
|
|
{
|
|
TD.RoutingServiceTransmitSucceeded(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), currentDest.CurrentEndpoint.ToString());
|
|
}
|
|
MoveToNextClientOperation(messageRpc.Operations.Count);
|
|
}
|
|
|
|
void MoveToNextClientOperation(int operationCount)
|
|
{
|
|
if (++this.destinationIndex >= operationCount)
|
|
{
|
|
//We've processed all multicasts for a given MessageRpc, move on to the next message (if any)
|
|
this.destinationIndex = 0;
|
|
|
|
// If we're one-way non-transactional and non-ReceiveContext then
|
|
// we don't need to store messages for session replay or RC.Complete
|
|
if (!this.channelExtension.ReceiveContextEnabled && !this.channelExtension.TransactedReceiveEnabled)
|
|
{
|
|
this.service.SessionMessages.RemoveAt(this.sessionMessageIndex);
|
|
--this.sessionMessageIndex;
|
|
}
|
|
|
|
if (++this.sessionMessageIndex >= this.service.SessionMessages.Count)
|
|
{
|
|
this.DoneSendingMessages();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AbandonReceiveContexts()
|
|
{
|
|
if (this.channelExtension.ReceiveContextEnabled)
|
|
{
|
|
foreach (MessageRpc messageRpc in this.service.SessionMessages)
|
|
{
|
|
try
|
|
{
|
|
if (TD.RoutingServiceAbandoningReceiveContextIsEnabled())
|
|
{
|
|
TD.RoutingServiceAbandoningReceiveContext(messageRpc.EventTraceActivity, messageRpc.UniqueID);
|
|
}
|
|
messageRpc.ReceiveContext.Abandon(this.timeoutHelper.RemainingTime());
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
if (TD.RoutingServiceHandledExceptionIsEnabled())
|
|
{
|
|
TD.RoutingServiceHandledException(messageRpc.EventTraceActivity, e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DoneClosingChannels()
|
|
{
|
|
if (this.channelExtension.ReceiveContextEnabled)
|
|
{
|
|
this.ChangeState(ProcessingState.CompletingReceiveContexts);
|
|
}
|
|
else if (this.service.RetryTransaction != null || this.channelExtension.TransactedReceiveEnabled)
|
|
{
|
|
this.ChangeState(ProcessingState.CommittingTransaction);
|
|
}
|
|
else
|
|
{
|
|
this.ChangeState(ProcessingState.Completing);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DoneCommittingTransaction()
|
|
{
|
|
this.ChangeState(ProcessingState.Completing);
|
|
return true;
|
|
}
|
|
|
|
bool DoneCompletingReceiveContexts()
|
|
{
|
|
if (this.service.RetryTransaction != null || this.channelExtension.TransactedReceiveEnabled)
|
|
{
|
|
this.ChangeState(ProcessingState.CommittingTransaction);
|
|
}
|
|
else
|
|
{
|
|
this.ChangeState(ProcessingState.Completing);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DoneInitializing()
|
|
{
|
|
this.ChangeState(ProcessingState.SendingSessionMessages);
|
|
return true;
|
|
}
|
|
|
|
bool DoneSendingMessages()
|
|
{
|
|
if (this.closeOutboundChannels)
|
|
{
|
|
this.ChangeState(ProcessingState.ClosingChannels);
|
|
}
|
|
else if (this.channelExtension.HasSession)
|
|
{
|
|
this.ChangeState(ProcessingState.Completing);
|
|
}
|
|
else if (this.channelExtension.ReceiveContextEnabled)
|
|
{
|
|
this.ChangeState(ProcessingState.CompletingReceiveContexts);
|
|
}
|
|
else if (this.service.RetryTransaction != null || this.channelExtension.TransactedReceiveEnabled)
|
|
{
|
|
this.ChangeState(ProcessingState.CommittingTransaction);
|
|
}
|
|
else
|
|
{
|
|
this.ChangeState(ProcessingState.Completing);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CloseCurrentChannel()
|
|
{
|
|
this.client = this.channelExtension.SessionChannels.ReleaseChannel();
|
|
|
|
if (this.client == null)
|
|
{
|
|
return this.DoneClosingChannels();
|
|
}
|
|
|
|
try
|
|
{
|
|
if (TD.RoutingServiceClosingClientIsEnabled())
|
|
{
|
|
TD.RoutingServiceClosingClient(this.client.Key.ToString());
|
|
}
|
|
IAsyncResult result;
|
|
using (this.PrepareTransactionalCall(this.service.GetTransactionForSending(null)))
|
|
{
|
|
result = ((ICommunicationObject)this.client).BeginClose(this.timeoutHelper.RemainingTime(),
|
|
this.PrepareAsyncCompletion(channelCloseCallback), this);
|
|
}
|
|
|
|
if (this.CheckSyncContinue(result))
|
|
{
|
|
this.ChannelCloseComplete(result);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (this.HandleCloseFailure(exception))
|
|
{
|
|
return true;
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
static bool ChannelCloseCallback(IAsyncResult result)
|
|
{
|
|
ProcessMessagesAsyncResult<TContract> thisPtr = (ProcessMessagesAsyncResult<TContract>)result.AsyncState;
|
|
FxTrace.Trace.SetAndTraceTransfer(thisPtr.channelExtension.ActivityID, true);
|
|
try
|
|
{
|
|
thisPtr.allCompletedSync = false;
|
|
try
|
|
{
|
|
thisPtr.ChannelCloseComplete(result);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (!thisPtr.HandleCloseFailure(exception))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
thisPtr.ProcessWhileSync();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
thisPtr.Fault(e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ChannelCloseComplete(IAsyncResult result)
|
|
{
|
|
((ICommunicationObject)this.client).EndClose(result);
|
|
}
|
|
|
|
bool HandleClientOperationFailure(Exception e)
|
|
{
|
|
if (TD.RoutingServiceTransmitFailedIsEnabled())
|
|
{
|
|
TD.RoutingServiceTransmitFailed(null, this.client.Key.ToString(), e);
|
|
}
|
|
|
|
if (!(e is CommunicationException || e is TimeoutException))
|
|
{
|
|
//We only move to backup for CommunicationExceptions and TimeoutExceptions
|
|
return false;
|
|
}
|
|
|
|
bool canHandle;
|
|
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
|
|
SendOperation sendOperation = messageRpc.Operations[this.destinationIndex];
|
|
|
|
if ((e is CommunicationObjectAbortedException || e is CommunicationObjectFaultedException) &&
|
|
!this.channelExtension.HasSession)
|
|
{
|
|
// Messages on a non sessionful channel share outbound connections and can
|
|
// fail due to other messages failing on the same channel
|
|
bool canRetry = (this.channelExtension.ReceiveContextEnabled || !this.channelExtension.TransactedReceiveEnabled);
|
|
if (canRetry && !this.abortedRetry)
|
|
{
|
|
//No session and ReceiveContext or non transactional, retry the message 1 time (before moving to backup)
|
|
this.abortedRetry = true;
|
|
this.ResetState();
|
|
return true;
|
|
}
|
|
}
|
|
else if (e is EndpointNotFoundException)
|
|
{
|
|
// The channel may not fault for this exception for bindings other than netTcpBinding
|
|
// We abort the channel in that case. We proactively clean up so that we don't have to cleanup later
|
|
SessionChannels sessionChannels = this.service.GetSessionChannels(messageRpc.Impersonating);
|
|
if (sessionChannels != null)
|
|
{
|
|
sessionChannels.AbortChannel(sendOperation.CurrentEndpoint);
|
|
}
|
|
}
|
|
else if (e is MessageSecurityException)
|
|
{
|
|
// The service may have been stopped and restarted without the routing service knowledge.
|
|
// When we try to use a cached channel to the service, the channel can fault due to this exception
|
|
// The faulted channel gets cleaned up and we retry one more time only when service has backup
|
|
// If there is no backup, we do not retry since we do not create a buffered message to prevent performance degradation
|
|
if (!this.abortedRetry && (sendOperation.AlternateEndpointCount > 0))
|
|
{
|
|
this.abortedRetry = true;
|
|
this.ResetState();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (sendOperation.TryMoveToAlternate(e))
|
|
{
|
|
if (TD.RoutingServiceMovedToBackupIsEnabled())
|
|
{
|
|
TD.RoutingServiceMovedToBackup(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), sendOperation.CurrentEndpoint.ToString());
|
|
}
|
|
this.ResetState();
|
|
canHandle = true;
|
|
}
|
|
else if (this.service.GetTransactionForSending(messageRpc) == null)
|
|
{
|
|
// This is OneWay with no Transaction...
|
|
// store this exception for when we complete, but continue any multicasting
|
|
this.service.SessionException = e;
|
|
|
|
// Mark the SendOperation as 'Sent' because there's no more work we can do (non-tx and no more backups)
|
|
sendOperation.TransmitSucceeded(null);
|
|
|
|
if (this.channelExtension.HasSession)
|
|
{
|
|
this.channelExtension.SessionChannels.AbortChannel(this.client.Key);
|
|
}
|
|
|
|
this.MoveToNextClientOperation(messageRpc.Operations.Count);
|
|
canHandle = true;
|
|
}
|
|
else
|
|
{
|
|
canHandle = false;
|
|
}
|
|
|
|
return canHandle;
|
|
}
|
|
|
|
// A Sessionful channel failed when closing, find all messages that went on that
|
|
// session/channel and move them to their backup endpoints
|
|
bool HandleCloseFailure(Exception e)
|
|
{
|
|
if (!(e is CommunicationException || e is TimeoutException))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (TD.RoutingServiceCloseFailedIsEnabled())
|
|
{
|
|
TD.RoutingServiceCloseFailed(this.client.Key.ToString(), e);
|
|
}
|
|
this.channelExtension.SessionChannels.AbortChannel(this.client.Key);
|
|
|
|
if (this.service.SessionMessages.Count == 0)
|
|
{
|
|
//All messages have been sent and we're non-transactional
|
|
Fx.Assert(!this.service.ChannelExtension.TransactedReceiveEnabled, "Should only happen for non-transactional cases");
|
|
return true;
|
|
}
|
|
|
|
foreach (MessageRpc messageRpc in this.service.SessionMessages)
|
|
{
|
|
for (this.destinationIndex = 0; this.destinationIndex < messageRpc.Operations.Count; this.destinationIndex++)
|
|
{
|
|
SendOperation sendOperation = messageRpc.Operations[this.destinationIndex];
|
|
if (client.Key.Equals(sendOperation.CurrentEndpoint))
|
|
{
|
|
if (!sendOperation.TryMoveToAlternate(e))
|
|
{
|
|
return false;
|
|
}
|
|
if (TD.RoutingServiceMovedToBackupIsEnabled())
|
|
{
|
|
TD.RoutingServiceMovedToBackup(messageRpc.EventTraceActivity, messageRpc.UniqueID, this.destinationIndex.ToString(TD.Culture), sendOperation.CurrentEndpoint.ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.ResetState();
|
|
return true;
|
|
}
|
|
|
|
bool CompleteCurrentReceiveContext()
|
|
{
|
|
if (this.service.SessionException != null)
|
|
{
|
|
//This means at least one multicast branch did not reach any of the configured endpoints
|
|
this.Fault(this.service.SessionException);
|
|
return false;
|
|
}
|
|
|
|
bool keepGoing;
|
|
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
|
|
if (messageRpc.ReceiveContext != null)
|
|
{
|
|
if (TD.RoutingServiceCompletingReceiveContextIsEnabled())
|
|
{
|
|
TD.RoutingServiceCompletingReceiveContext(messageRpc.EventTraceActivity, messageRpc.UniqueID);
|
|
}
|
|
|
|
IAsyncResult result;
|
|
using (this.PrepareTransactionalCall(this.service.GetTransactionForSending(messageRpc)))
|
|
{
|
|
result = messageRpc.ReceiveContext.BeginComplete(this.timeoutHelper.RemainingTime(),
|
|
this.PrepareAsyncCompletion(completeReceiveContextCallback), this);
|
|
}
|
|
if (this.CheckSyncContinue(result))
|
|
{
|
|
keepGoing = this.CompleteReceiveContextCompleted(result);
|
|
}
|
|
else
|
|
{
|
|
keepGoing = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Either all messages have RC or all messages don't have RC. Since we don't have one
|
|
// we know that none of these messages will, so we don't have to look at the other messages
|
|
Fx.Assert("We shouldn't enter CompletingReceiveContexts state if the binding is not ReceiveContext capable");
|
|
keepGoing = this.DoneCompletingReceiveContexts();
|
|
}
|
|
|
|
return keepGoing;
|
|
}
|
|
|
|
static bool CompleteReceiveContextCallback(IAsyncResult result)
|
|
{
|
|
ProcessMessagesAsyncResult<TContract> thisPtr = (ProcessMessagesAsyncResult<TContract>)result.AsyncState;
|
|
FxTrace.Trace.SetAndTraceTransfer(thisPtr.channelExtension.ActivityID, true);
|
|
try
|
|
{
|
|
thisPtr.allCompletedSync = false;
|
|
if (thisPtr.CompleteReceiveContextCompleted(result))
|
|
{
|
|
thisPtr.ProcessWhileSync();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
thisPtr.Fault(e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CompleteReceiveContextCompleted(IAsyncResult result)
|
|
{
|
|
MessageRpc messageRpc = this.service.SessionMessages[this.sessionMessageIndex];
|
|
messageRpc.ReceiveContext.EndComplete(result);
|
|
|
|
if (++this.sessionMessageIndex >= this.service.SessionMessages.Count)
|
|
{
|
|
return this.DoneCompletingReceiveContexts();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CommitTransaction()
|
|
{
|
|
if (this.service.RetryTransaction != null)
|
|
{
|
|
if (TD.RoutingServiceCommittingTransactionIsEnabled())
|
|
{
|
|
TD.RoutingServiceCommittingTransaction(this.service.RetryTransaction.TransactionInformation.LocalIdentifier);
|
|
}
|
|
|
|
IAsyncResult result = this.service.RetryTransaction.BeginCommit(
|
|
this.PrepareAsyncCompletion(commitTransactionCallback), this);
|
|
if (this.CheckSyncContinue(result))
|
|
{
|
|
return this.CommitTransactionCompleted(result);
|
|
}
|
|
return false;
|
|
}
|
|
else if (this.channelExtension.TransactedReceiveEnabled)
|
|
{
|
|
if (TD.RoutingServiceCommittingTransactionIsEnabled())
|
|
{
|
|
Transaction transaction = this.service.GetTransactionForSending(null);
|
|
TD.RoutingServiceCommittingTransaction(transaction != null ? transaction.TransactionInformation.LocalIdentifier : string.Empty);
|
|
}
|
|
}
|
|
|
|
return this.DoneCommittingTransaction();
|
|
}
|
|
|
|
static bool CommitTransactionCallback(IAsyncResult result)
|
|
{
|
|
ProcessMessagesAsyncResult<TContract> thisPtr = (ProcessMessagesAsyncResult<TContract>)result.AsyncState;
|
|
FxTrace.Trace.SetAndTraceTransfer(thisPtr.channelExtension.ActivityID, true);
|
|
try
|
|
{
|
|
thisPtr.allCompletedSync = false;
|
|
if (thisPtr.CommitTransactionCompleted(result))
|
|
{
|
|
thisPtr.ProcessWhileSync();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
thisPtr.Fault(e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CommitTransactionCompleted(IAsyncResult result)
|
|
{
|
|
this.service.RetryTransaction.EndCommit(result);
|
|
return this.DoneCommittingTransaction();
|
|
}
|
|
|
|
void CompleteSelf(Exception operationException)
|
|
{
|
|
Exception exception = operationException;
|
|
if (exception == null && (this.closeOutboundChannels || !this.channelExtension.HasSession))
|
|
{
|
|
// It's possible that this last operation in a session didn't result in an exception
|
|
// but we still have an exception to report when closing the session...
|
|
exception = this.service.SessionException;
|
|
}
|
|
|
|
if (!this.closeOutboundChannels)
|
|
{
|
|
//When we're closing the channels that means end of session, there's no message per se.
|
|
if (TD.RoutingServiceCompletingOneWayIsEnabled()) { TD.RoutingServiceCompletingOneWay(exception); }
|
|
}
|
|
this.Complete(this.allCompletedSync, exception);
|
|
}
|
|
|
|
internal static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<ProcessMessagesAsyncResult<TContract>>(result);
|
|
}
|
|
|
|
void Fault(Exception e)
|
|
{
|
|
this.service.ResetSession();
|
|
this.AbandonReceiveContexts();
|
|
|
|
this.CompleteSelf(e);
|
|
}
|
|
|
|
enum ProcessingState
|
|
{
|
|
Initial = 0,
|
|
SendingSessionMessages,
|
|
ClosingChannels,
|
|
CompletingReceiveContexts,
|
|
CommittingTransaction,
|
|
Completing,
|
|
Completed
|
|
}
|
|
}
|
|
}
|