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
1165 lines
42 KiB
C#
1165 lines
42 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Runtime;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
sealed class ReliableRequestSessionChannel : RequestChannel, IRequestSessionChannel
|
|
{
|
|
IClientReliableChannelBinder binder;
|
|
ChannelParameterCollection channelParameters;
|
|
ReliableRequestor closeRequestor;
|
|
ReliableOutputConnection connection;
|
|
bool isLastKnown = false;
|
|
Exception maxRetryCountException = null;
|
|
static AsyncCallback onPollingComplete = Fx.ThunkCallback(new AsyncCallback(OnPollingComplete));
|
|
SequenceRangeCollection ranges = SequenceRangeCollection.Empty;
|
|
Guard replyAckConsistencyGuard;
|
|
ClientReliableSession session;
|
|
IReliableFactorySettings settings;
|
|
InterruptibleWaitObject shutdownHandle;
|
|
ReliableRequestor terminateRequestor;
|
|
|
|
public ReliableRequestSessionChannel(
|
|
ChannelManagerBase factory,
|
|
IReliableFactorySettings settings,
|
|
IClientReliableChannelBinder binder,
|
|
FaultHelper faultHelper,
|
|
LateBoundChannelParameterCollection channelParameters,
|
|
UniqueId inputID)
|
|
: base(factory, binder.RemoteAddress, binder.Via, true)
|
|
{
|
|
this.settings = settings;
|
|
this.binder = binder;
|
|
this.session = new ClientReliableSession(this, settings, binder, faultHelper, inputID);
|
|
this.session.PollingCallback = this.PollingCallback;
|
|
this.session.UnblockChannelCloseCallback = this.UnblockClose;
|
|
|
|
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
this.shutdownHandle = new InterruptibleWaitObject(false);
|
|
}
|
|
else
|
|
{
|
|
this.replyAckConsistencyGuard = new Guard(Int32.MaxValue);
|
|
}
|
|
|
|
this.binder.Faulted += OnBinderFaulted;
|
|
this.binder.OnException += OnBinderException;
|
|
|
|
this.channelParameters = channelParameters;
|
|
channelParameters.SetChannel(this);
|
|
}
|
|
|
|
public IOutputSession Session
|
|
{
|
|
get
|
|
{
|
|
return this.session;
|
|
}
|
|
}
|
|
|
|
void AddAcknowledgementHeader(Message message, bool force)
|
|
{
|
|
if (this.ranges.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
WsrmUtilities.AddAcknowledgementHeader(this.settings.ReliableMessagingVersion, message,
|
|
this.session.InputID, this.ranges, this.isLastKnown);
|
|
}
|
|
|
|
IAsyncResult BeginCloseBinder(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.binder.BeginClose(timeout, MaskingMode.Handled, callback, state);
|
|
}
|
|
|
|
IAsyncResult BeginTerminateSequence(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
this.CreateTerminateRequestor();
|
|
return this.terminateRequestor.BeginRequest(timeout, callback, state);
|
|
}
|
|
|
|
void CloseSequence(TimeSpan timeout)
|
|
{
|
|
this.CreateCloseRequestor();
|
|
Message closeReply = this.closeRequestor.Request(timeout);
|
|
this.ProcessCloseOrTerminateReply(true, closeReply);
|
|
}
|
|
|
|
IAsyncResult BeginCloseSequence(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
this.CreateCloseRequestor();
|
|
return this.closeRequestor.BeginRequest(timeout, callback, state);
|
|
}
|
|
|
|
void EndCloseSequence(IAsyncResult result)
|
|
{
|
|
Message closeReply = this.closeRequestor.EndRequest(result);
|
|
this.ProcessCloseOrTerminateReply(true, closeReply);
|
|
}
|
|
|
|
void ConfigureRequestor(ReliableRequestor requestor)
|
|
{
|
|
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
|
|
requestor.MessageVersion = this.settings.MessageVersion;
|
|
requestor.Binder = this.binder;
|
|
requestor.SetRequestResponsePattern();
|
|
requestor.MessageHeader = new WsrmAcknowledgmentHeader(reliableMessagingVersion, this.session.InputID,
|
|
this.ranges, true, -1);
|
|
}
|
|
|
|
Message CreateAckRequestedMessage()
|
|
{
|
|
Message request = WsrmUtilities.CreateAckRequestedMessage(this.settings.MessageVersion,
|
|
this.settings.ReliableMessagingVersion, this.session.OutputID);
|
|
this.AddAcknowledgementHeader(request, true);
|
|
return request;
|
|
}
|
|
|
|
protected override IAsyncRequest CreateAsyncRequest(Message message, AsyncCallback callback, object state)
|
|
{
|
|
return new AsyncRequest(this, callback, state);
|
|
}
|
|
|
|
void CreateCloseRequestor()
|
|
{
|
|
RequestReliableRequestor temp = new RequestReliableRequestor();
|
|
|
|
this.ConfigureRequestor(temp);
|
|
temp.TimeoutString1Index = SR.TimeoutOnClose;
|
|
temp.MessageAction = WsrmIndex.GetCloseSequenceActionHeader(
|
|
this.settings.MessageVersion.Addressing);
|
|
temp.MessageBody = new CloseSequence(this.session.OutputID, this.connection.Last);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ThrowIfClosed();
|
|
this.closeRequestor = temp;
|
|
}
|
|
}
|
|
|
|
protected override IRequest CreateRequest(Message message)
|
|
{
|
|
return new SyncRequest(this);
|
|
}
|
|
|
|
void CreateTerminateRequestor()
|
|
{
|
|
RequestReliableRequestor temp = new RequestReliableRequestor();
|
|
|
|
this.ConfigureRequestor(temp);
|
|
temp.MessageAction = WsrmIndex.GetTerminateSequenceActionHeader(
|
|
this.settings.MessageVersion.Addressing, this.settings.ReliableMessagingVersion);
|
|
temp.MessageBody = new TerminateSequence(this.settings.ReliableMessagingVersion,
|
|
this.session.OutputID, this.connection.Last);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ThrowIfClosed();
|
|
this.terminateRequestor = temp;
|
|
this.session.CloseSession();
|
|
}
|
|
}
|
|
|
|
void EndCloseBinder(IAsyncResult result)
|
|
{
|
|
this.binder.EndClose(result);
|
|
}
|
|
|
|
void EndTerminateSequence(IAsyncResult result)
|
|
{
|
|
Message terminateReply = this.terminateRequestor.EndRequest(result);
|
|
|
|
if (terminateReply != null)
|
|
{
|
|
this.ProcessCloseOrTerminateReply(false, terminateReply);
|
|
}
|
|
}
|
|
|
|
Exception GetInvalidAddException()
|
|
{
|
|
if (this.State == CommunicationState.Faulted)
|
|
return this.GetTerminalException();
|
|
else
|
|
return this.CreateClosedException();
|
|
}
|
|
|
|
public override T GetProperty<T>()
|
|
{
|
|
if (typeof(T) == typeof(IRequestSessionChannel))
|
|
{
|
|
return (T)(object)this;
|
|
}
|
|
|
|
if (typeof(T) == typeof(ChannelParameterCollection))
|
|
{
|
|
return (T)(object)this.channelParameters;
|
|
}
|
|
|
|
T baseProperty = base.GetProperty<T>();
|
|
|
|
if (baseProperty != null)
|
|
{
|
|
return baseProperty;
|
|
}
|
|
|
|
T innerProperty = this.binder.Channel.GetProperty<T>();
|
|
if ((innerProperty == null) && (typeof(T) == typeof(FaultConverter)))
|
|
{
|
|
return (T)(object)FaultConverter.GetDefaultFaultConverter(this.settings.MessageVersion);
|
|
}
|
|
else
|
|
{
|
|
return innerProperty;
|
|
}
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
if (this.connection != null)
|
|
{
|
|
this.connection.Abort(this);
|
|
}
|
|
|
|
if (this.shutdownHandle != null)
|
|
{
|
|
this.shutdownHandle.Abort(this);
|
|
}
|
|
|
|
ReliableRequestor tempRequestor = this.closeRequestor;
|
|
if (tempRequestor != null)
|
|
{
|
|
tempRequestor.Abort(this);
|
|
}
|
|
|
|
tempRequestor = this.terminateRequestor;
|
|
if (tempRequestor != null)
|
|
{
|
|
tempRequestor.Abort(this);
|
|
}
|
|
|
|
this.session.Abort();
|
|
base.OnAbort();
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
bool wsrm11 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
|
|
|
|
OperationWithTimeoutBeginCallback[] beginCallbacks = new OperationWithTimeoutBeginCallback[] {
|
|
this.connection.BeginClose,
|
|
this.BeginWaitForShutdown,
|
|
wsrm11 ? this.BeginCloseSequence : default(OperationWithTimeoutBeginCallback),
|
|
this.BeginTerminateSequence,
|
|
this.session.BeginClose,
|
|
this.BeginCloseBinder
|
|
};
|
|
|
|
OperationEndCallback[] endCallbacks = new OperationEndCallback[] {
|
|
this.connection.EndClose,
|
|
this.EndWaitForShutdown,
|
|
wsrm11 ? this.EndCloseSequence : default(OperationEndCallback),
|
|
this.EndTerminateSequence,
|
|
this.session.EndClose,
|
|
this.EndCloseBinder
|
|
};
|
|
|
|
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout, beginCallbacks, endCallbacks, callback, state);
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new ReliableChannelOpenAsyncResult(this.binder, this.session, timeout,
|
|
callback, state);
|
|
}
|
|
|
|
void OnBinderException(IReliableChannelBinder sender, Exception exception)
|
|
{
|
|
if (exception is QuotaExceededException)
|
|
{
|
|
if (this.State == CommunicationState.Opening ||
|
|
this.State == CommunicationState.Opened ||
|
|
this.State == CommunicationState.Closing)
|
|
{
|
|
this.session.OnLocalFault(exception, SequenceTerminatedFault.CreateQuotaExceededFault(this.session.OutputID), null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.AddPendingException(exception);
|
|
}
|
|
}
|
|
|
|
void OnBinderFaulted(IReliableChannelBinder sender, Exception exception)
|
|
{
|
|
this.binder.Abort();
|
|
|
|
if (this.State == CommunicationState.Opening ||
|
|
this.State == CommunicationState.Opened ||
|
|
this.State == CommunicationState.Closing)
|
|
{
|
|
exception = new CommunicationException(SR.GetString(SR.EarlySecurityFaulted), exception);
|
|
this.session.OnLocalFault(exception, (Message)null, null);
|
|
}
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.connection.Close(timeoutHelper.RemainingTime());
|
|
this.WaitForShutdown(timeoutHelper.RemainingTime());
|
|
|
|
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
this.CloseSequence(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
this.TerminateSequence(timeoutHelper.RemainingTime());
|
|
this.session.Close(timeoutHelper.RemainingTime());
|
|
this.binder.Close(timeoutHelper.RemainingTime(), MaskingMode.Handled);
|
|
}
|
|
|
|
protected override void OnClosed()
|
|
{
|
|
base.OnClosed();
|
|
this.binder.Faulted -= this.OnBinderFaulted;
|
|
}
|
|
|
|
IAsyncResult OnConnectionBeginSend(MessageAttemptInfo attemptInfo, TimeSpan timeout,
|
|
bool maskUnhandledException, AsyncCallback callback, object state)
|
|
{
|
|
if (attemptInfo.RetryCount > this.settings.MaxRetryCount)
|
|
{
|
|
if (TD.MaxRetryCyclesExceededIsEnabled())
|
|
{
|
|
TD.MaxRetryCyclesExceeded(SR.GetString(SR.MaximumRetryCountExceeded));
|
|
}
|
|
this.session.OnLocalFault(new CommunicationException(SR.GetString(SR.MaximumRetryCountExceeded), this.maxRetryCountException),
|
|
SequenceTerminatedFault.CreateMaxRetryCountExceededFault(this.session.OutputID), null);
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
else
|
|
{
|
|
this.session.OnLocalActivity();
|
|
this.AddAcknowledgementHeader(attemptInfo.Message, false);
|
|
|
|
ReliableBinderRequestAsyncResult result = new ReliableBinderRequestAsyncResult(callback, state);
|
|
result.Binder = this.binder;
|
|
result.MessageAttemptInfo = attemptInfo;
|
|
result.MaskingMode = maskUnhandledException ? MaskingMode.Unhandled : MaskingMode.None;
|
|
|
|
if (attemptInfo.RetryCount < this.settings.MaxRetryCount)
|
|
{
|
|
result.MaskingMode |= MaskingMode.Handled;
|
|
result.SaveHandledException = false;
|
|
}
|
|
else
|
|
{
|
|
result.SaveHandledException = true;
|
|
}
|
|
|
|
result.Begin(timeout);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
void OnConnectionEndSend(IAsyncResult result)
|
|
{
|
|
if (result is CompletedAsyncResult)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
else
|
|
{
|
|
Exception handledException;
|
|
Message reply = ReliableBinderRequestAsyncResult.End(result, out handledException);
|
|
ReliableBinderRequestAsyncResult requestResult = (ReliableBinderRequestAsyncResult)result;
|
|
if (requestResult.MessageAttemptInfo.RetryCount == this.settings.MaxRetryCount)
|
|
{
|
|
this.maxRetryCountException = handledException;
|
|
}
|
|
|
|
if (reply != null)
|
|
{
|
|
this.ProcessReply(reply, (IReliableRequest)requestResult.MessageAttemptInfo.State,
|
|
requestResult.MessageAttemptInfo.GetSequenceNumber());
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnConnectionSend(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException)
|
|
{
|
|
using (attemptInfo.Message)
|
|
{
|
|
if (attemptInfo.RetryCount > this.settings.MaxRetryCount)
|
|
{
|
|
if (TD.MaxRetryCyclesExceededIsEnabled())
|
|
{
|
|
TD.MaxRetryCyclesExceeded(SR.GetString(SR.MaximumRetryCountExceeded));
|
|
}
|
|
this.session.OnLocalFault(new CommunicationException(SR.GetString(SR.MaximumRetryCountExceeded), this.maxRetryCountException),
|
|
SequenceTerminatedFault.CreateMaxRetryCountExceededFault(this.session.OutputID), null);
|
|
return;
|
|
}
|
|
|
|
this.AddAcknowledgementHeader(attemptInfo.Message, false);
|
|
this.session.OnLocalActivity();
|
|
|
|
Message reply = null;
|
|
MaskingMode maskingMode = maskUnhandledException ? MaskingMode.Unhandled : MaskingMode.None;
|
|
|
|
if (attemptInfo.RetryCount < this.settings.MaxRetryCount)
|
|
{
|
|
maskingMode |= MaskingMode.Handled;
|
|
reply = this.binder.Request(attemptInfo.Message, timeout, maskingMode);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
reply = this.binder.Request(attemptInfo.Message, timeout, maskingMode);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
if (this.binder.IsHandleable(e))
|
|
{
|
|
this.maxRetryCountException = e;
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (reply != null)
|
|
ProcessReply(reply, (IReliableRequest)attemptInfo.State, attemptInfo.GetSequenceNumber());
|
|
}
|
|
}
|
|
|
|
void OnConnectionSendAckRequested(TimeSpan timeout)
|
|
{
|
|
// do nothing, only replies to sequence messages alter the state of the reliable output connection
|
|
}
|
|
|
|
IAsyncResult OnConnectionBeginSendAckRequested(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
// do nothing, only replies to sequence messages alter the state of the reliable output connection
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
|
|
void OnConnectionEndSendAckRequested(IAsyncResult result)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
|
|
void OnComponentFaulted(Exception faultException, WsrmFault fault)
|
|
{
|
|
this.session.OnLocalFault(faultException, fault, null);
|
|
}
|
|
|
|
void OnComponentException(Exception exception)
|
|
{
|
|
this.session.OnUnknownException(exception);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
ReliableChannelOpenAsyncResult.End(result);
|
|
}
|
|
|
|
protected override void OnFaulted()
|
|
{
|
|
this.session.OnFaulted();
|
|
this.UnblockClose();
|
|
base.OnFaulted();
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
bool throwing = true;
|
|
|
|
try
|
|
{
|
|
this.binder.Open(timeoutHelper.RemainingTime());
|
|
this.session.Open(timeoutHelper.RemainingTime());
|
|
throwing = false;
|
|
}
|
|
finally
|
|
{
|
|
if (throwing)
|
|
{
|
|
this.binder.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnOpened()
|
|
{
|
|
base.OnOpened();
|
|
this.connection = new ReliableOutputConnection(this.session.OutputID, this.settings.MaxTransferWindowSize,
|
|
this.settings.MessageVersion, this.settings.ReliableMessagingVersion, this.session.InitiationTime,
|
|
false, this.DefaultSendTimeout);
|
|
this.connection.Faulted += OnComponentFaulted;
|
|
this.connection.OnException += OnComponentException;
|
|
this.connection.BeginSendHandler = OnConnectionBeginSend;
|
|
this.connection.EndSendHandler = OnConnectionEndSend;
|
|
this.connection.SendHandler = OnConnectionSend;
|
|
this.connection.BeginSendAckRequestedHandler = OnConnectionBeginSendAckRequested;
|
|
this.connection.EndSendAckRequestedHandler = OnConnectionEndSendAckRequested;
|
|
this.connection.SendAckRequestedHandler = OnConnectionSendAckRequested;
|
|
}
|
|
|
|
static void OnPollingComplete(IAsyncResult result)
|
|
{
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
ReliableRequestSessionChannel channel = (ReliableRequestSessionChannel)result.AsyncState;
|
|
channel.EndSendAckRequestedMessage(result);
|
|
}
|
|
}
|
|
|
|
void PollingCallback()
|
|
{
|
|
IAsyncResult result = this.BeginSendAckRequestedMessage(this.DefaultSendTimeout, MaskingMode.All,
|
|
onPollingComplete, this);
|
|
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
this.EndSendAckRequestedMessage(result);
|
|
}
|
|
}
|
|
|
|
void ProcessCloseOrTerminateReply(bool close, Message reply)
|
|
{
|
|
if (reply == null)
|
|
{
|
|
// In the close case, the requestor is configured to throw TimeoutException instead of returning null.
|
|
// In the terminate case, this value can be null, but the caller should not call this method.
|
|
throw Fx.AssertAndThrow("Argument reply cannot be null.");
|
|
}
|
|
|
|
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
|
|
|
|
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
if (close)
|
|
{
|
|
throw Fx.AssertAndThrow("Close does not exist in Feb2005.");
|
|
}
|
|
|
|
reply.Close();
|
|
}
|
|
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
WsrmMessageInfo info = this.closeRequestor.GetInfo();
|
|
|
|
// Close - Final ack made it.
|
|
// Terminate - UnknownSequence.
|
|
// Either way, message has been verified and does not belong to this thread.
|
|
if (info != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
info = WsrmMessageInfo.Get(this.settings.MessageVersion, reliableMessagingVersion,
|
|
this.binder.Channel, this.binder.GetInnerSession(), reply);
|
|
this.session.ProcessInfo(info, null, true);
|
|
this.session.VerifyDuplexProtocolElements(info, null, true);
|
|
|
|
WsrmFault fault = close
|
|
? WsrmUtilities.ValidateCloseSequenceResponse(this.session, this.closeRequestor.MessageId, info,
|
|
this.connection.Last)
|
|
: WsrmUtilities.ValidateTerminateSequenceResponse(this.session, this.terminateRequestor.MessageId,
|
|
info, this.connection.Last);
|
|
|
|
if (fault != null)
|
|
{
|
|
this.session.OnLocalFault(null, fault, null);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
reply.Close();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
|
|
}
|
|
}
|
|
|
|
void ProcessReply(Message reply, IReliableRequest request, Int64 requestSequenceNumber)
|
|
{
|
|
WsrmMessageInfo messageInfo = WsrmMessageInfo.Get(this.settings.MessageVersion,
|
|
this.settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), reply);
|
|
|
|
if (!this.session.ProcessInfo(messageInfo, null))
|
|
return;
|
|
|
|
if (!this.session.VerifyDuplexProtocolElements(messageInfo, null))
|
|
return;
|
|
|
|
bool wsrm11 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
|
|
|
|
if (messageInfo.WsrmHeaderFault != null)
|
|
{
|
|
// Close message now, going to stop processing in all cases.
|
|
messageInfo.Message.Close();
|
|
|
|
if (!(messageInfo.WsrmHeaderFault is UnknownSequenceFault))
|
|
{
|
|
throw Fx.AssertAndThrow("Fault must be UnknownSequence fault.");
|
|
}
|
|
|
|
if (this.terminateRequestor == null)
|
|
{
|
|
throw Fx.AssertAndThrow("If we start getting UnknownSequence, terminateRequestor cannot be null.");
|
|
}
|
|
|
|
this.terminateRequestor.SetInfo(messageInfo);
|
|
|
|
return;
|
|
}
|
|
|
|
if (messageInfo.AcknowledgementInfo == null)
|
|
{
|
|
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
|
|
SR.GetString(SR.SequenceTerminatedReplyMissingAcknowledgement),
|
|
SR.GetString(SR.ReplyMissingAcknowledgement));
|
|
messageInfo.Message.Close();
|
|
this.session.OnLocalFault(fault.CreateException(), fault, null);
|
|
return;
|
|
}
|
|
|
|
if (wsrm11 && (messageInfo.TerminateSequenceInfo != null))
|
|
{
|
|
UniqueId faultId = (messageInfo.TerminateSequenceInfo.Identifier == this.session.OutputID)
|
|
? this.session.InputID
|
|
: this.session.OutputID;
|
|
|
|
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(faultId,
|
|
SR.GetString(SR.SequenceTerminatedUnsupportedTerminateSequence),
|
|
SR.GetString(SR.UnsupportedTerminateSequenceExceptionString));
|
|
messageInfo.Message.Close();
|
|
this.session.OnLocalFault(fault.CreateException(), fault, null);
|
|
return;
|
|
}
|
|
else if (wsrm11 && messageInfo.AcknowledgementInfo.Final)
|
|
{
|
|
// Close message now, going to stop processing in all cases.
|
|
messageInfo.Message.Close();
|
|
|
|
if (this.closeRequestor == null)
|
|
{
|
|
// Remote endpoint signaled Close, this is not allowed so we fault.
|
|
string exceptionString = SR.GetString(SR.UnsupportedCloseExceptionString);
|
|
string faultString = SR.GetString(SR.SequenceTerminatedUnsupportedClose);
|
|
|
|
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultString,
|
|
exceptionString);
|
|
this.session.OnLocalFault(fault.CreateException(), fault, null);
|
|
}
|
|
else
|
|
{
|
|
WsrmFault fault = WsrmUtilities.ValidateFinalAck(this.session, messageInfo, this.connection.Last);
|
|
|
|
if (fault == null)
|
|
{
|
|
// Received valid final ack after sending Close, inform the close thread.
|
|
this.closeRequestor.SetInfo(messageInfo);
|
|
}
|
|
else
|
|
{
|
|
// Received invalid final ack after sending Close, fault.
|
|
this.session.OnLocalFault(fault.CreateException(), fault, null);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int bufferRemaining = -1;
|
|
|
|
if (this.settings.FlowControlEnabled)
|
|
bufferRemaining = messageInfo.AcknowledgementInfo.BufferRemaining;
|
|
|
|
// We accept no more than MaxSequenceRanges ranges to limit the serialized ack size and
|
|
// the amount of memory taken up by the ack ranges. Since request reply uses the presence of
|
|
// a reply as an acknowledgement we cannot call ProcessTransferred (which stops retrying the
|
|
// request) if we intend to drop the message. This means the limit is not strict since we do
|
|
// not check for the limit and merge the ranges atomically. The limit + the number of
|
|
// concurrent threads is a sufficient mitigation.
|
|
if ((messageInfo.SequencedMessageInfo != null) &&
|
|
!ReliableInputConnection.CanMerge(messageInfo.SequencedMessageInfo.SequenceNumber, this.ranges))
|
|
{
|
|
messageInfo.Message.Close();
|
|
return;
|
|
}
|
|
|
|
bool exitGuard = this.replyAckConsistencyGuard != null ? this.replyAckConsistencyGuard.Enter() : false;
|
|
|
|
try
|
|
{
|
|
this.connection.ProcessTransferred(requestSequenceNumber,
|
|
messageInfo.AcknowledgementInfo.Ranges, bufferRemaining);
|
|
|
|
this.session.OnRemoteActivity(this.connection.Strategy.QuotaRemaining == 0);
|
|
|
|
if (messageInfo.SequencedMessageInfo != null)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ranges = this.ranges.MergeWith(messageInfo.SequencedMessageInfo.SequenceNumber);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (exitGuard)
|
|
{
|
|
this.replyAckConsistencyGuard.Exit();
|
|
}
|
|
}
|
|
|
|
if (request != null)
|
|
{
|
|
if (WsrmUtilities.IsWsrmAction(this.settings.ReliableMessagingVersion, messageInfo.Action))
|
|
{
|
|
messageInfo.Message.Close();
|
|
request.Set(null);
|
|
}
|
|
else
|
|
{
|
|
request.Set(messageInfo.Message);
|
|
}
|
|
}
|
|
|
|
// The termination mechanism in the TerminateSequence fails with RequestReply.
|
|
// Since the ack ranges are updated after ProcessTransferred is called and
|
|
// ProcessTransferred potentially signals the Termination process, this channel
|
|
// winds up sending a message with the ack for last message missing.
|
|
// Thus we send the termination after we update the ranges.
|
|
|
|
if ((this.shutdownHandle != null) && this.connection.CheckForTermination())
|
|
{
|
|
this.shutdownHandle.Set();
|
|
}
|
|
|
|
if (request != null)
|
|
request.Complete();
|
|
}
|
|
|
|
IAsyncResult BeginSendAckRequestedMessage(TimeSpan timeout, MaskingMode maskingMode, AsyncCallback callback,
|
|
object state)
|
|
{
|
|
this.session.OnLocalActivity();
|
|
ReliableBinderRequestAsyncResult requestResult = new ReliableBinderRequestAsyncResult(callback, state);
|
|
requestResult.Binder = this.binder;
|
|
requestResult.MaskingMode = maskingMode;
|
|
requestResult.Message = this.CreateAckRequestedMessage();
|
|
requestResult.Begin(timeout);
|
|
|
|
return requestResult;
|
|
}
|
|
|
|
void EndSendAckRequestedMessage(IAsyncResult result)
|
|
{
|
|
Message reply = ReliableBinderRequestAsyncResult.End(result);
|
|
|
|
if (reply != null)
|
|
{
|
|
this.ProcessReply(reply, null, 0);
|
|
}
|
|
}
|
|
|
|
void TerminateSequence(TimeSpan timeout)
|
|
{
|
|
this.CreateTerminateRequestor();
|
|
Message terminateReply = this.terminateRequestor.Request(timeout);
|
|
|
|
if (terminateReply != null)
|
|
{
|
|
this.ProcessCloseOrTerminateReply(false, terminateReply);
|
|
}
|
|
}
|
|
|
|
void UnblockClose()
|
|
{
|
|
FaultPendingRequests();
|
|
|
|
if (this.connection != null)
|
|
{
|
|
this.connection.Fault(this);
|
|
}
|
|
|
|
if (this.shutdownHandle != null)
|
|
{
|
|
this.shutdownHandle.Fault(this);
|
|
}
|
|
|
|
ReliableRequestor tempRequestor = this.closeRequestor;
|
|
if (tempRequestor != null)
|
|
{
|
|
tempRequestor.Fault(this);
|
|
}
|
|
|
|
tempRequestor = this.terminateRequestor;
|
|
if (tempRequestor != null)
|
|
{
|
|
tempRequestor.Fault(this);
|
|
}
|
|
}
|
|
|
|
void WaitForShutdown(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
this.shutdownHandle.Wait(timeoutHelper.RemainingTime());
|
|
}
|
|
else
|
|
{
|
|
this.isLastKnown = true;
|
|
|
|
// We already closed the connection so we know everything was acknowledged.
|
|
// Make sure the reply acknowledgement ranges are current.
|
|
this.replyAckConsistencyGuard.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
IAsyncResult BeginWaitForShutdown(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
return this.shutdownHandle.BeginWait(timeout, callback, state);
|
|
}
|
|
else
|
|
{
|
|
this.isLastKnown = true;
|
|
|
|
// We already closed the connection so we know everything was acknowledged.
|
|
// Make sure the reply acknowledgement ranges are current.
|
|
return this.replyAckConsistencyGuard.BeginClose(timeout, callback, state);
|
|
}
|
|
}
|
|
|
|
void EndWaitForShutdown(IAsyncResult result)
|
|
{
|
|
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
this.shutdownHandle.EndWait(result);
|
|
}
|
|
else
|
|
{
|
|
this.replyAckConsistencyGuard.EndClose(result);
|
|
}
|
|
}
|
|
|
|
interface IReliableRequest : IRequestBase
|
|
{
|
|
void Set(Message reply);
|
|
void Complete();
|
|
}
|
|
|
|
class SyncRequest : IReliableRequest, IRequest
|
|
{
|
|
bool aborted = false;
|
|
bool completed = false;
|
|
ManualResetEvent completedHandle;
|
|
bool faulted = false;
|
|
TimeSpan originalTimeout;
|
|
Message reply;
|
|
ReliableRequestSessionChannel parent;
|
|
object thisLock = new object();
|
|
|
|
public SyncRequest(ReliableRequestSessionChannel parent)
|
|
{
|
|
this.parent = parent;
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
|
|
public void Abort(RequestChannel channel)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.completed)
|
|
{
|
|
this.aborted = true;
|
|
this.completed = true;
|
|
|
|
if (this.completedHandle != null)
|
|
this.completedHandle.Set();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Fault(RequestChannel channel)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.completed)
|
|
{
|
|
this.faulted = true;
|
|
this.completed = true;
|
|
|
|
if (this.completedHandle != null)
|
|
this.completedHandle.Set();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Complete()
|
|
{
|
|
}
|
|
|
|
public void SendRequest(Message message, TimeSpan timeout)
|
|
{
|
|
this.originalTimeout = timeout;
|
|
if (!parent.connection.AddMessage(message, timeout, this))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.GetInvalidAddException());
|
|
}
|
|
|
|
public void Set(Message reply)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.completed)
|
|
{
|
|
this.reply = reply;
|
|
this.completed = true;
|
|
|
|
if (this.completedHandle != null)
|
|
this.completedHandle.Set();
|
|
|
|
return;
|
|
}
|
|
}
|
|
if (reply != null)
|
|
{
|
|
reply.Close();
|
|
}
|
|
}
|
|
|
|
public Message WaitForReply(TimeSpan timeout)
|
|
{
|
|
bool throwing = true;
|
|
|
|
try
|
|
{
|
|
bool expired = false;
|
|
|
|
if (!this.completed)
|
|
{
|
|
bool wait = false;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.completed)
|
|
{
|
|
wait = true;
|
|
this.completedHandle = new ManualResetEvent(false);
|
|
}
|
|
}
|
|
|
|
if (wait)
|
|
{
|
|
expired = !TimeoutHelper.WaitOne(this.completedHandle, timeout);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.completed)
|
|
{
|
|
this.completed = true;
|
|
}
|
|
else
|
|
{
|
|
expired = false;
|
|
}
|
|
}
|
|
|
|
this.completedHandle.Close();
|
|
}
|
|
}
|
|
|
|
if (this.aborted)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.CreateClosedException());
|
|
}
|
|
else if (this.faulted)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.GetTerminalException());
|
|
}
|
|
else if (expired)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.TimeoutOnRequest, this.originalTimeout)));
|
|
}
|
|
else
|
|
{
|
|
throwing = false;
|
|
return this.reply;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (throwing)
|
|
{
|
|
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(this.parent.session.InputID,
|
|
SR.GetString(SR.SequenceTerminatedReliableRequestThrew), null);
|
|
this.parent.session.OnLocalFault(null, fault, null);
|
|
if (this.completedHandle != null)
|
|
this.completedHandle.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnReleaseRequest()
|
|
{
|
|
}
|
|
}
|
|
|
|
class AsyncRequest : AsyncResult, IReliableRequest, IAsyncRequest
|
|
{
|
|
bool completed = false;
|
|
ReliableRequestSessionChannel parent;
|
|
Message reply;
|
|
bool set = false;
|
|
object thisLock = new object();
|
|
|
|
public AsyncRequest(ReliableRequestSessionChannel parent, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.parent = parent;
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
|
|
public void Abort(RequestChannel channel)
|
|
{
|
|
if (this.ShouldComplete())
|
|
{
|
|
this.Complete(false, parent.CreateClosedException());
|
|
}
|
|
}
|
|
|
|
public void Fault(RequestChannel channel)
|
|
{
|
|
if (this.ShouldComplete())
|
|
{
|
|
this.Complete(false, parent.GetTerminalException());
|
|
}
|
|
}
|
|
|
|
void AddCompleted(IAsyncResult result)
|
|
{
|
|
Exception completeException = null;
|
|
|
|
try
|
|
{
|
|
if (!parent.connection.EndAddMessage(result))
|
|
completeException = this.parent.GetInvalidAddException();
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
completeException = e;
|
|
}
|
|
|
|
if (completeException != null && this.ShouldComplete())
|
|
this.Complete(result.CompletedSynchronously, completeException);
|
|
}
|
|
|
|
public void BeginSendRequest(Message message, TimeSpan timeout)
|
|
{
|
|
parent.connection.BeginAddMessage(message, timeout, this, Fx.ThunkCallback(new AsyncCallback(AddCompleted)), null);
|
|
}
|
|
|
|
public void Complete()
|
|
{
|
|
if (this.ShouldComplete())
|
|
{
|
|
this.Complete(false, null);
|
|
}
|
|
}
|
|
|
|
public Message End()
|
|
{
|
|
AsyncResult.End<AsyncRequest>(this);
|
|
return this.reply;
|
|
}
|
|
|
|
public void Set(Message reply)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.set)
|
|
{
|
|
this.reply = reply;
|
|
this.set = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (reply != null)
|
|
{
|
|
reply.Close();
|
|
}
|
|
}
|
|
|
|
bool ShouldComplete()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.completed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
this.completed = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void OnReleaseRequest()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|