Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

2014 lines
74 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.Threading;
using System.Xml;
// Note on locking:
// The following rule must be followed in order to avoid deadlocks: ReliableRequestContext
// locks MUST NOT be taken while under the ReliableReplySessionChannel lock.
//
// lock(context)-->lock(channel) ok.
// lock(channel)-->lock(context) BAD!
//
sealed class ReliableReplySessionChannel : ReplyChannel, IReplySessionChannel
{
List<Int64> acked = new List<Int64>();
static Action<object> asyncReceiveComplete = new Action<object>(AsyncReceiveCompleteStatic);
IServerReliableChannelBinder binder;
ReplyHelper closeSequenceReplyHelper;
ReliableInputConnection connection;
bool contextAborted;
DeliveryStrategy<RequestContext> deliveryStrategy;
ReliableRequestContext lastReply;
bool lastReplyAcked;
Int64 lastReplySequenceNumber = Int64.MinValue;
ReliableChannelListenerBase<IReplySessionChannel> listener;
InterruptibleWaitObject messagingCompleteWaitObject;
Int64 nextReplySequenceNumber;
static AsyncCallback onReceiveCompleted = Fx.ThunkCallback(new AsyncCallback(OnReceiveCompletedStatic));
string perfCounterId;
Dictionary<Int64, ReliableRequestContext> requestsByRequestSequenceNumber = new Dictionary<Int64, ReliableRequestContext>();
Dictionary<Int64, ReliableRequestContext> requestsByReplySequenceNumber = new Dictionary<Int64, ReliableRequestContext>();
ServerReliableSession session;
ReplyHelper terminateSequenceReplyHelper;
public ReliableReplySessionChannel(
ReliableChannelListenerBase<IReplySessionChannel> listener,
IServerReliableChannelBinder binder,
FaultHelper faultHelper,
UniqueId inputID,
UniqueId outputID)
: base(listener, binder.LocalAddress)
{
this.listener = listener;
this.connection = new ReliableInputConnection();
this.connection.ReliableMessagingVersion = this.listener.ReliableMessagingVersion;
this.binder = binder;
this.session = new ServerReliableSession(this, listener, binder, faultHelper, inputID, outputID);
this.session.UnblockChannelCloseCallback = this.UnblockClose;
if (this.listener.Ordered)
this.deliveryStrategy = new OrderedDeliveryStrategy<RequestContext>(this, this.listener.MaxTransferWindowSize, true);
else
this.deliveryStrategy = new UnorderedDeliveryStrategy<RequestContext>(this, this.listener.MaxTransferWindowSize);
this.binder.Faulted += OnBinderFaulted;
this.binder.OnException += OnBinderException;
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.messagingCompleteWaitObject = new InterruptibleWaitObject(false);
}
this.session.Open(TimeSpan.Zero);
if (PerformanceCounters.PerformanceCountersEnabled)
this.perfCounterId = this.listener.Uri.ToString().ToUpperInvariant();
if (binder.HasSession)
{
try
{
this.StartReceiving(false);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.session.OnUnknownException(e);
}
}
}
public IServerReliableChannelBinder Binder
{
get
{
return this.binder;
}
}
bool IsMessagingCompleted
{
get
{
lock (this.ThisLock)
{
return this.connection.AllAdded && (this.requestsByRequestSequenceNumber.Count == 0) && this.lastReplyAcked;
}
}
}
MessageVersion MessageVersion
{
get
{
return this.listener.MessageVersion;
}
}
int PendingRequestContexts
{
get
{
lock (this.ThisLock)
{
return (this.requestsByRequestSequenceNumber.Count - this.requestsByReplySequenceNumber.Count);
}
}
}
public IInputSession Session
{
get
{
return this.session;
}
}
void AbortContexts()
{
lock (this.ThisLock)
{
if (this.contextAborted)
return;
this.contextAborted = true;
}
Dictionary<Int64, ReliableRequestContext>.ValueCollection contexts = this.requestsByRequestSequenceNumber.Values;
foreach (ReliableRequestContext request in contexts)
{
request.Abort();
}
this.requestsByRequestSequenceNumber.Clear();
this.requestsByReplySequenceNumber.Clear();
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.lastReply != null)
this.lastReply.Abort();
}
}
void AddAcknowledgementHeader(Message message)
{
WsrmUtilities.AddAcknowledgementHeader(
this.listener.ReliableMessagingVersion,
message,
this.session.InputID,
this.connection.Ranges,
this.connection.IsLastKnown,
this.listener.MaxTransferWindowSize - this.deliveryStrategy.EnqueuedCount);
}
static void AsyncReceiveCompleteStatic(object state)
{
IAsyncResult result = (IAsyncResult)state;
ReliableReplySessionChannel channel = (ReliableReplySessionChannel)(result.AsyncState);
try
{
if (channel.HandleReceiveComplete(result))
{
channel.StartReceiving(true);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
channel.session.OnUnknownException(e);
}
}
IAsyncResult BeginCloseBinder(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.binder.BeginClose(timeout, MaskingMode.Handled, callback, state);
}
IAsyncResult BeginCloseOutput(TimeSpan timeout, AsyncCallback callback, object state)
{
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
ReliableRequestContext reply = this.lastReply;
if (reply == null)
return new CloseOutputCompletedAsyncResult(callback, state);
else
return reply.BeginReplyInternal(null, timeout, callback, state);
}
else
{
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.CreateCloseSequenceReplyHelper();
}
return this.closeSequenceReplyHelper.BeginWaitAndReply(timeout, callback, state);
}
}
IAsyncResult BeginUnregisterChannel(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.listener.OnReliableChannelBeginClose(this.session.InputID,
this.session.OutputID, timeout, callback, state);
}
Message CreateAcknowledgement(SequenceRangeCollection ranges)
{
Message message = WsrmUtilities.CreateAcknowledgmentMessage(
this.MessageVersion,
this.listener.ReliableMessagingVersion,
this.session.InputID,
ranges,
this.connection.IsLastKnown,
this.listener.MaxTransferWindowSize - this.deliveryStrategy.EnqueuedCount);
return message;
}
Message CreateSequenceClosedFault()
{
Message message = new SequenceClosedFault(this.session.InputID).CreateMessage(
this.listener.MessageVersion, this.listener.ReliableMessagingVersion);
this.AddAcknowledgementHeader(message);
return message;
}
bool CreateCloseSequenceReplyHelper()
{
if (this.State == CommunicationState.Faulted || this.Aborted)
{
return false;
}
if (this.closeSequenceReplyHelper == null)
{
this.closeSequenceReplyHelper = new ReplyHelper(this, CloseSequenceReplyProvider.Instance,
true);
}
return true;
}
bool CreateTerminateSequenceReplyHelper()
{
if (this.State == CommunicationState.Faulted || this.Aborted)
{
return false;
}
if (this.terminateSequenceReplyHelper == null)
{
this.terminateSequenceReplyHelper = new ReplyHelper(this,
TerminateSequenceReplyProvider.Instance, false);
}
return true;
}
void CloseOutput(TimeSpan timeout)
{
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
ReliableRequestContext reply = this.lastReply;
if (reply != null)
reply.ReplyInternal(null, timeout);
}
else
{
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.CreateCloseSequenceReplyHelper();
}
this.closeSequenceReplyHelper.WaitAndReply(timeout);
}
}
bool ContainsRequest(Int64 requestSeqNum)
{
lock (this.ThisLock)
{
bool haveRequestInDictionary = this.requestsByRequestSequenceNumber.ContainsKey(requestSeqNum);
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
return (haveRequestInDictionary
|| ((this.lastReply != null) && (this.lastReply.RequestSequenceNumber == requestSeqNum) && (!this.lastReplyAcked)));
}
else
{
return haveRequestInDictionary;
}
}
}
void EndCloseBinder(IAsyncResult result)
{
this.binder.EndClose(result);
}
void EndCloseOutput(IAsyncResult result)
{
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (result is CloseOutputCompletedAsyncResult)
CloseOutputCompletedAsyncResult.End(result);
else
this.lastReply.EndReplyInternal(result);
}
else
{
this.closeSequenceReplyHelper.EndWaitAndReply(result);
}
}
void EndUnregisterChannel(IAsyncResult result)
{
this.listener.OnReliableChannelEndClose(result);
}
public override T GetProperty<T>()
{
if (typeof(T) == typeof(IReplySessionChannel))
{
return (T)(object)this;
}
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.listener.MessageVersion);
}
else
{
return innerProperty;
}
}
bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
if (this.Binder.EndTryReceive(result, out context))
{
if (context == null)
{
bool terminated = false;
lock (this.ThisLock)
{
terminated = this.connection.Terminate();
}
if (!terminated && (this.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(SR.GetString(SR.EarlySecurityClose));
this.session.OnLocalFault(e, (Message)null, null);
}
return false;
}
WsrmMessageInfo info = WsrmMessageInfo.Get(this.listener.MessageVersion,
this.listener.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(),
context.RequestMessage);
this.StartReceiving(false);
this.ProcessRequest(context, info);
return false;
}
return true;
}
protected override void OnAbort()
{
if (this.closeSequenceReplyHelper != null)
{
this.closeSequenceReplyHelper.Abort();
}
this.connection.Abort(this);
if (this.terminateSequenceReplyHelper != null)
{
this.terminateSequenceReplyHelper.Abort();
}
this.session.Abort();
this.AbortContexts();
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.messagingCompleteWaitObject.Abort(this);
}
this.listener.OnReliableChannelAbort(this.session.InputID, this.session.OutputID);
base.OnAbort();
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfCloseInvalid();
bool wsrmFeb2005 = this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
OperationWithTimeoutBeginCallback[] beginOperations =
new OperationWithTimeoutBeginCallback[] {
new OperationWithTimeoutBeginCallback (this.BeginCloseOutput),
wsrmFeb2005
? new OperationWithTimeoutBeginCallback(this.connection.BeginClose)
: new OperationWithTimeoutBeginCallback(this.BeginTerminateSequence),
wsrmFeb2005
? new OperationWithTimeoutBeginCallback(this.messagingCompleteWaitObject.BeginWait)
: new OperationWithTimeoutBeginCallback(this.connection.BeginClose),
new OperationWithTimeoutBeginCallback(this.session.BeginClose),
new OperationWithTimeoutBeginCallback(this.BeginCloseBinder),
new OperationWithTimeoutBeginCallback(this.BeginUnregisterChannel),
new OperationWithTimeoutBeginCallback(base.OnBeginClose)
};
OperationEndCallback[] endOperations =
new OperationEndCallback[] {
new OperationEndCallback(this.EndCloseOutput),
wsrmFeb2005
? new OperationEndCallback(this.connection.EndClose)
: new OperationEndCallback(this.EndTerminateSequence),
wsrmFeb2005
? new OperationEndCallback(this.messagingCompleteWaitObject.EndWait)
: new OperationEndCallback(this.connection.EndClose),
new OperationEndCallback(this.session.EndClose),
new OperationEndCallback(this.EndCloseBinder),
new OperationEndCallback(this.EndUnregisterChannel),
new OperationEndCallback(base.OnEndClose)
};
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout,
beginOperations, endOperations, callback, state);
}
void OnBinderException(IReliableChannelBinder sender, Exception exception)
{
if (exception is QuotaExceededException)
this.session.OnLocalFault(exception, (Message)null, null);
else
this.EnqueueAndDispatch(exception, null, false);
}
void OnBinderFaulted(IReliableChannelBinder sender, Exception exception)
{
this.binder.Abort();
exception = new CommunicationException(SR.GetString(SR.EarlySecurityFaulted), exception);
this.session.OnLocalFault(exception, (Message)null, null);
}
protected override void OnClose(TimeSpan timeout)
{
this.ThrowIfCloseInvalid();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.CloseOutput(timeoutHelper.RemainingTime());
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.connection.Close(timeoutHelper.RemainingTime());
this.messagingCompleteWaitObject.Wait(timeoutHelper.RemainingTime());
}
else
{
this.TerminateSequence(timeoutHelper.RemainingTime());
this.connection.Close(timeoutHelper.RemainingTime());
}
this.session.Close(timeoutHelper.RemainingTime());
this.binder.Close(timeoutHelper.RemainingTime(), MaskingMode.Handled);
this.listener.OnReliableChannelClose(this.session.InputID, this.session.OutputID,
timeoutHelper.RemainingTime());
base.OnClose(timeoutHelper.RemainingTime());
}
protected override void OnClosed()
{
this.deliveryStrategy.Dispose();
this.binder.Faulted -= this.OnBinderFaulted;
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.lastReply != null)
{
this.lastReply.Abort();
}
}
base.OnClosed();
}
protected override void OnEndClose(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
protected override void OnFaulted()
{
this.session.OnFaulted();
this.UnblockClose();
base.OnFaulted();
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.SessionFaulted(this.perfCounterId);
}
static void OnReceiveCompletedStatic(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
ReliableReplySessionChannel channel = (ReliableReplySessionChannel)(result.AsyncState);
try
{
if (channel.HandleReceiveComplete(result))
{
channel.StartReceiving(true);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
channel.session.OnUnknownException(e);
}
}
void OnTerminateSequenceCompleted()
{
if ((this.session.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
&& this.connection.IsSequenceClosed)
{
lock (this.ThisLock)
{
this.connection.Terminate();
}
}
}
bool PrepareReply(ReliableRequestContext context)
{
lock (this.ThisLock)
{
if (this.Aborted || this.State == CommunicationState.Faulted || this.State == CommunicationState.Closed)
return false;
long requestSequenceNumber = context.RequestSequenceNumber;
bool wsrmFeb2005 = this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
if (wsrmFeb2005 && (this.connection.Last == requestSequenceNumber))
{
if (this.lastReply == null)
this.lastReply = context;
this.requestsByRequestSequenceNumber.Remove(requestSequenceNumber);
bool canReply = this.connection.AllAdded && (this.State == CommunicationState.Closing);
if (!canReply)
return false;
}
else
{
if (this.State == CommunicationState.Closing)
return false;
if (!context.HasReply)
{
this.requestsByRequestSequenceNumber.Remove(requestSequenceNumber);
return true;
}
}
// won't throw if you do not need next sequence number
if (this.nextReplySequenceNumber == Int64.MaxValue)
{
MessageNumberRolloverFault fault = new MessageNumberRolloverFault(this.session.OutputID);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
context.SetReplySequenceNumber(++this.nextReplySequenceNumber);
if (wsrmFeb2005 && (this.connection.Last == requestSequenceNumber))
{
if (!context.HasReply)
this.lastReplyAcked = true; //If Last Reply has no user data, it does not need to be acked. Here we just set it as its ack received.
this.lastReplySequenceNumber = this.nextReplySequenceNumber;
context.SetLastReply(this.lastReplySequenceNumber);
}
else if (context.HasReply)
{
this.requestsByReplySequenceNumber.Add(this.nextReplySequenceNumber, context);
}
return true;
}
}
Message PrepareReplyMessage(Int64 replySequenceNumber, bool isLast, SequenceRangeCollection ranges, Message reply)
{
this.AddAcknowledgementHeader(reply);
WsrmUtilities.AddSequenceHeader(
this.listener.ReliableMessagingVersion,
reply,
this.session.OutputID,
replySequenceNumber,
isLast);
return reply;
}
void ProcessAcknowledgment(WsrmAcknowledgmentInfo info)
{
lock (this.ThisLock)
{
if (this.Aborted || this.State == CommunicationState.Faulted || this.State == CommunicationState.Closed)
return;
if (this.requestsByReplySequenceNumber.Count > 0)
{
Int64 reply;
this.acked.Clear();
foreach (KeyValuePair<Int64, ReliableRequestContext> pair in this.requestsByReplySequenceNumber)
{
reply = pair.Key;
if (info.Ranges.Contains(reply))
{
this.acked.Add(reply);
}
}
for (int i = 0; i < this.acked.Count; i++)
{
reply = this.acked[i];
this.requestsByRequestSequenceNumber.Remove(
this.requestsByReplySequenceNumber[reply].RequestSequenceNumber);
this.requestsByReplySequenceNumber.Remove(reply);
}
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (!this.lastReplyAcked && (this.lastReplySequenceNumber != Int64.MinValue))
{
this.lastReplyAcked = info.Ranges.Contains(this.lastReplySequenceNumber);
}
}
}
}
}
void ProcessAckRequested(RequestContext context)
{
try
{
using (Message reply = CreateAcknowledgement(this.connection.Ranges))
{
context.Reply(reply);
}
}
finally
{
context.RequestMessage.Close();
context.Close();
}
}
void ProcessShutdown11(RequestContext context, WsrmMessageInfo info)
{
bool cleanup = true;
try
{
bool isTerminate = (info.TerminateSequenceInfo != null);
WsrmRequestInfo requestInfo = isTerminate
? (WsrmRequestInfo)info.TerminateSequenceInfo
: (WsrmRequestInfo)info.CloseSequenceInfo;
Int64 last = isTerminate ? info.TerminateSequenceInfo.LastMsgNumber : info.CloseSequenceInfo.LastMsgNumber;
if (!WsrmUtilities.ValidateWsrmRequest(this.session, requestInfo, this.binder, context))
{
cleanup = false;
return;
}
bool scheduleShutdown = false;
Exception remoteFaultException = null;
ReplyHelper closeHelper = null;
bool haveAllReplyAcks = true;
bool isLastLargeEnough = true;
bool isLastConsistent = true;
lock (this.ThisLock)
{
if (!this.connection.IsLastKnown)
{
// All requests and replies must be acknowledged.
if (this.requestsByRequestSequenceNumber.Count == 0)
{
if (isTerminate)
{
if (this.connection.SetTerminateSequenceLast(last, out isLastLargeEnough))
{
scheduleShutdown = true;
}
else if (isLastLargeEnough)
{
remoteFaultException = new ProtocolException(SR.GetString(SR.EarlyTerminateSequence));
}
}
else
{
scheduleShutdown = this.connection.SetCloseSequenceLast(last);
isLastLargeEnough = scheduleShutdown;
}
if (scheduleShutdown)
{
// (1) !isTerminate && !IsLastKnown, CloseSequence received before TerminateSequence.
// - Need to ensure helper to delay the reply until Close.
// (2) isTerminate && !IsLastKnown, TerminateSequence received before CloseSequence.
// - Close not required, ensure it is created so we can bypass it.
if (!this.CreateCloseSequenceReplyHelper())
{
return;
}
// Capture the helper in order to unblock it.
if (isTerminate)
{
closeHelper = this.closeSequenceReplyHelper;
}
this.session.SetFinalAck(this.connection.Ranges);
this.deliveryStrategy.Dispose();
}
}
else
{
haveAllReplyAcks = false;
}
}
else
{
isLastConsistent = (last == this.connection.Last);
}
}
WsrmFault fault = null;
if (!isLastLargeEnough)
{
string faultString = SR.GetString(SR.SequenceTerminatedSmallLastMsgNumber);
string exceptionString = SR.GetString(SR.SmallLastMsgNumberExceptionString);
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID, faultString,
exceptionString);
}
else if (!haveAllReplyAcks)
{
string faultString = SR.GetString(SR.SequenceTerminatedNotAllRepliesAcknowledged);
string exceptionString = SR.GetString(SR.NotAllRepliesAcknowledgedExceptionString);
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultString,
exceptionString);
}
else if (!isLastConsistent)
{
string faultString = SR.GetString(SR.SequenceTerminatedInconsistentLastMsgNumber);
string exceptionString = SR.GetString(SR.InconsistentLastMsgNumberExceptionString);
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
faultString, exceptionString);
}
else if (remoteFaultException != null)
{
Message message = WsrmUtilities.CreateTerminateMessage(this.MessageVersion,
this.listener.ReliableMessagingVersion, this.session.OutputID);
this.AddAcknowledgementHeader(message);
using (message)
{
context.Reply(message);
}
this.session.OnRemoteFault(remoteFaultException);
return;
}
if (fault != null)
{
this.session.OnLocalFault(fault.CreateException(), fault, context);
cleanup = false;
return;
}
if (isTerminate)
{
if (closeHelper != null)
{
closeHelper.UnblockWaiter();
}
lock (this.ThisLock)
{
if (!this.CreateTerminateSequenceReplyHelper())
{
return;
}
}
}
ReplyHelper replyHelper = isTerminate ? this.terminateSequenceReplyHelper : this.closeSequenceReplyHelper;
if (!replyHelper.TransferRequestContext(context, info))
{
replyHelper.Reply(context, info, this.DefaultSendTimeout, MaskingMode.All);
if (isTerminate)
{
this.OnTerminateSequenceCompleted();
}
}
else
{
cleanup = false;
}
if (scheduleShutdown)
{
ActionItem.Schedule(this.ShutdownCallback, null);
}
}
finally
{
if (cleanup)
{
context.RequestMessage.Close();
context.Close();
}
}
}
public void ProcessDemuxedRequest(RequestContext context, WsrmMessageInfo info)
{
try
{
this.ProcessRequest(context, info);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
this.session.OnUnknownException(e);
}
}
void ProcessRequest(RequestContext context, WsrmMessageInfo info)
{
bool closeMessage = true;
bool closeContext = true;
try
{
if (!this.session.ProcessInfo(info, context))
{
closeMessage = false;
closeContext = false;
return;
}
if (!this.session.VerifyDuplexProtocolElements(info, context))
{
closeMessage = false;
closeContext = false;
return;
}
this.session.OnRemoteActivity(false);
if (info.CreateSequenceInfo != null)
{
EndpointAddress acksTo;
if (WsrmUtilities.ValidateCreateSequence<IReplySessionChannel>(info, this.listener, this.binder.Channel, out acksTo))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(this.listener.MessageVersion,
this.listener.ReliableMessagingVersion, true, info.CreateSequenceInfo,
this.listener.Ordered, this.session.InputID, acksTo);
using (context)
{
using (response)
{
if (this.Binder.AddressResponse(info.Message, response))
context.Reply(response, this.DefaultSendTimeout);
}
}
}
else
{
this.session.OnLocalFault(info.FaultException, info.FaultReply, context);
}
closeContext = false;
return;
}
closeContext = false;
if (info.AcknowledgementInfo != null)
{
ProcessAcknowledgment(info.AcknowledgementInfo);
closeContext = (info.Action == WsrmIndex.GetSequenceAcknowledgementActionString(this.listener.ReliableMessagingVersion));
}
if (!closeContext)
{
closeMessage = false;
if (info.SequencedMessageInfo != null)
{
ProcessSequencedMessage(context, info.Action, info.SequencedMessageInfo);
}
else if (info.TerminateSequenceInfo != null)
{
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
ProcessTerminateSequenceFeb2005(context, info);
}
else if (info.TerminateSequenceInfo.Identifier == this.session.InputID)
{
ProcessShutdown11(context, info);
}
else // Identifier == OutputID
{
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedUnsupportedTerminateSequence),
SR.GetString(SR.UnsupportedTerminateSequenceExceptionString));
this.session.OnLocalFault(fault.CreateException(), fault, context);
closeMessage = false;
closeContext = false;
return;
}
}
else if (info.CloseSequenceInfo != null)
{
ProcessShutdown11(context, info);
}
else if (info.AckRequestedInfo != null)
{
ProcessAckRequested(context);
}
}
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.IsMessagingCompleted)
{
this.messagingCompleteWaitObject.Set();
}
}
}
finally
{
if (closeMessage)
info.Message.Close();
if (closeContext)
context.Close();
}
}
// A given reliable request can be in one of three states:
// 1. Known and Processing: A ReliableRequestContext exists in requestTable but the outcome for
// for the request is unknown. Any transport request referencing this reliable request
// (by means of the sequence number) must be held until the outcome becomes known.
// 2. Known and Processed: A ReliableRequestContext exists in the requestTable and the outcome for
// for the request is known. The ReliableRequestContext holds that outcome. Any transport requests
// referening this reliable request must send the response dictated by the outcome.
// 3. Unknown: No ReliableRequestContext exists in the requestTable for the referenced reliable request.
// In this case a new ReliableRequestContext is added to the requestTable to await some outcome.
//
// There are 4 possible outcomes for a reliable request:
// a. It is captured and the user replies. Transport replies are then copies of the user's reply.
// b. It is captured and the user closes the context. Transport replies are then acknowledgments
// that include the sequence number of the reliable request.
// c. It is captured and and the user aborts the context. Transport contexts are then aborted.
// d. It is not captured. In this case an acknowledgment that includes all sequence numbers
// previously captured is sent. Note two sub-cases here:
// 1. It is not captured because it is dropped (e.g. it doesn't fit in the buffer). In this
// case the reliable request's sequence number is not in the acknowledgment.
// 2. It is not captured because it is a duplicate. In this case the reliable request's
// sequence number is included in the acknowledgment.
//
// By following these rules it is possible to support one-way and two-operations without having
// knowledge of them (the user drives using the request context we give them) and at the same time
// it is possible to forget about past replies once acknowledgments for them are received.
void ProcessSequencedMessage(RequestContext context, string action, WsrmSequencedMessageInfo info)
{
ReliableRequestContext reliableContext = null;
WsrmFault fault = null;
bool needDispatch = false;
bool scheduleShutdown = false;
bool wsrmFeb2005 = this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
Int64 requestSequenceNumber = info.SequenceNumber;
bool isLast = wsrmFeb2005 && info.LastMessage;
bool isLastOnly = wsrmFeb2005 && (action == WsrmFeb2005Strings.LastMessageAction);
bool isDupe;
Message message = null;
lock (this.ThisLock)
{
if (this.Aborted || this.State == CommunicationState.Faulted || this.State == CommunicationState.Closed)
{
context.RequestMessage.Close();
context.Abort();
return;
}
isDupe = this.connection.Ranges.Contains(requestSequenceNumber);
if (!this.connection.IsValid(requestSequenceNumber, isLast))
{
if (wsrmFeb2005)
{
fault = new LastMessageNumberExceededFault(this.session.InputID);
}
else
{
message = this.CreateSequenceClosedFault();
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
else if (isDupe)
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
if (!this.requestsByRequestSequenceNumber.TryGetValue(info.SequenceNumber, out reliableContext))
{
if ((this.lastReply != null) && (this.lastReply.RequestSequenceNumber == info.SequenceNumber))
reliableContext = this.lastReply;
else
reliableContext = new ReliableRequestContext(context, info.SequenceNumber, this, true);
}
reliableContext.SetAckRanges(this.connection.Ranges);
}
else if ((this.State == CommunicationState.Closing) && !isLastOnly)
{
if (wsrmFeb2005)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone),
SR.GetString(SR.SessionClosedBeforeDone));
}
else
{
message = this.CreateSequenceClosedFault();
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
// In the unordered case we accept no more than MaxSequenceRanges ranges to limit the
// serialized ack size and the amount of memory taken by the ack ranges. In the
// ordered case, the delivery strategy MaxTransferWindowSize quota mitigates this
// threat.
else if (this.deliveryStrategy.CanEnqueue(requestSequenceNumber)
&& (this.requestsByReplySequenceNumber.Count < this.listener.MaxTransferWindowSize)
&& (this.listener.Ordered || this.connection.CanMerge(requestSequenceNumber)))
{
this.connection.Merge(requestSequenceNumber, isLast);
reliableContext = new ReliableRequestContext(context, info.SequenceNumber, this, false);
reliableContext.SetAckRanges(this.connection.Ranges);
if (!isLastOnly)
{
needDispatch = this.deliveryStrategy.Enqueue(reliableContext, requestSequenceNumber);
this.requestsByRequestSequenceNumber.Add(info.SequenceNumber, reliableContext);
}
else
{
this.lastReply = reliableContext;
}
scheduleShutdown = this.connection.AllAdded;
}
else
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
if (fault != null)
{
this.session.OnLocalFault(fault.CreateException(), fault, context);
return;
}
if (reliableContext == null)
{
if (message != null)
{
using (message)
{
context.Reply(message);
}
}
context.RequestMessage.Close();
context.Close();
return;
}
if (isDupe && reliableContext.CheckForReplyOrAddInnerContext(context))
{
reliableContext.SendReply(context, MaskingMode.All);
return;
}
if (!isDupe && isLastOnly)
{
reliableContext.Close();
}
if (needDispatch)
{
this.Dispatch();
}
if (scheduleShutdown)
{
ActionItem.Schedule(this.ShutdownCallback, null);
}
}
void ProcessTerminateSequenceFeb2005(RequestContext context, WsrmMessageInfo info)
{
bool cleanup = true;
try
{
Message message = null;
bool isTerminateEarly;
bool haveAllReplyAcks;
lock (this.ThisLock)
{
isTerminateEarly = !this.connection.Terminate();
haveAllReplyAcks = this.requestsByRequestSequenceNumber.Count == 0;
}
WsrmFault fault = null;
if (isTerminateEarly)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedEarlyTerminateSequence),
SR.GetString(SR.EarlyTerminateSequence));
}
else if (!haveAllReplyAcks)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedBeforeReplySequenceAcked),
SR.GetString(SR.EarlyRequestTerminateSequence));
}
if (fault != null)
{
this.session.OnLocalFault(fault.CreateException(), fault, context);
cleanup = false;
return;
}
message = WsrmUtilities.CreateTerminateMessage(this.MessageVersion,
this.listener.ReliableMessagingVersion, this.session.OutputID);
this.AddAcknowledgementHeader(message);
using (message)
{
context.Reply(message);
}
}
finally
{
if (cleanup)
{
context.RequestMessage.Close();
context.Close();
}
}
}
void StartReceiving(bool canBlock)
{
while (true)
{
IAsyncResult result = this.binder.BeginTryReceive(TimeSpan.MaxValue, onReceiveCompleted, this);
if (!result.CompletedSynchronously)
{
return;
}
if (!canBlock)
{
ActionItem.Schedule(asyncReceiveComplete, result);
return;
}
if (!this.HandleReceiveComplete(result))
break;
}
}
void ShutdownCallback(object state)
{
this.Shutdown();
}
void TerminateSequence(TimeSpan timeout)
{
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.CreateTerminateSequenceReplyHelper();
}
this.terminateSequenceReplyHelper.WaitAndReply(timeout);
this.OnTerminateSequenceCompleted();
}
IAsyncResult BeginTerminateSequence(TimeSpan timeout, AsyncCallback callback, object state)
{
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.CreateTerminateSequenceReplyHelper();
}
return this.terminateSequenceReplyHelper.BeginWaitAndReply(timeout, callback, state);
}
void EndTerminateSequence(IAsyncResult result)
{
this.terminateSequenceReplyHelper.EndWaitAndReply(result);
this.OnTerminateSequenceCompleted();
}
void ThrowIfCloseInvalid()
{
bool shouldFault = false;
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.PendingRequestContexts != 0 || this.connection.Ranges.Count > 1)
{
shouldFault = true;
}
}
else if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.PendingRequestContexts != 0)
{
shouldFault = true;
}
}
if (shouldFault)
{
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone), SR.GetString(SR.SessionClosedBeforeDone));
this.session.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
}
void UnblockClose()
{
this.AbortContexts();
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.messagingCompleteWaitObject.Fault(this);
}
else
{
if (this.closeSequenceReplyHelper != null)
{
this.closeSequenceReplyHelper.Fault();
}
if (this.terminateSequenceReplyHelper != null)
{
this.terminateSequenceReplyHelper.Fault();
}
}
this.connection.Fault(this);
}
class CloseOutputCompletedAsyncResult : CompletedAsyncResult
{
public CloseOutputCompletedAsyncResult(AsyncCallback callback, object state)
: base(callback, state)
{
}
}
class ReliableRequestContext : RequestContextBase
{
MessageBuffer bufferedReply;
ReliableReplySessionChannel channel;
List<RequestContext> innerContexts = new List<RequestContext>();
bool isLastReply;
bool outcomeKnown;
SequenceRangeCollection ranges;
Int64 requestSequenceNumber;
Int64 replySequenceNumber;
public ReliableRequestContext(RequestContext context, Int64 requestSequenceNumber, ReliableReplySessionChannel channel, bool outcome)
: base(context.RequestMessage, channel.DefaultCloseTimeout, channel.DefaultSendTimeout)
{
this.channel = channel;
this.requestSequenceNumber = requestSequenceNumber;
this.outcomeKnown = outcome;
if (!outcome)
this.innerContexts.Add(context);
}
public bool CheckForReplyOrAddInnerContext(RequestContext innerContext)
{
lock (this.ThisLock)
{
if (this.outcomeKnown)
return true;
this.innerContexts.Add(innerContext);
return false;
}
}
public bool HasReply
{
get
{
return (this.bufferedReply != null);
}
}
public Int64 RequestSequenceNumber
{
get
{
return this.requestSequenceNumber;
}
}
void AbortInnerContexts()
{
for (int i = 0; i < this.innerContexts.Count; i++)
{
this.innerContexts[i].Abort();
this.innerContexts[i].RequestMessage.Close();
}
this.innerContexts.Clear();
}
internal IAsyncResult BeginReplyInternal(Message reply, TimeSpan timeout, AsyncCallback callback, object state)
{
bool needAbort = true;
bool needReply = true;
try
{
lock (this.ThisLock)
{
if (this.ranges == null)
{
throw Fx.AssertAndThrow("this.ranges != null");
}
if (this.Aborted)
{
needAbort = false;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationObjectAbortedException(SR.GetString(SR.RequestContextAborted)));
}
if (this.outcomeKnown)
{
needAbort = false;
needReply = false;
}
else
{
if ((reply != null) && (this.bufferedReply == null))
this.bufferedReply = reply.CreateBufferedCopy(int.MaxValue);
if (!this.channel.PrepareReply(this))
{
needAbort = false;
needReply = false;
}
else
{
this.outcomeKnown = true;
}
}
}
if (!needReply)
return new ReplyCompletedAsyncResult(callback, state);
IAsyncResult result = new ReplyAsyncResult(this, timeout, callback, state);
needAbort = false;
return result;
}
finally
{
if (needAbort)
{
this.AbortInnerContexts();
this.Abort();
}
}
}
internal void EndReplyInternal(IAsyncResult result)
{
if (result is ReplyCompletedAsyncResult)
{
ReplyCompletedAsyncResult.End(result);
return;
}
bool throwing = true;
try
{
ReplyAsyncResult.End(result);
this.innerContexts.Clear();
throwing = false;
}
finally
{
if (throwing)
{
this.AbortInnerContexts();
this.Abort();
}
}
}
protected override void OnAbort()
{
bool outcome;
lock (this.ThisLock)
{
outcome = this.outcomeKnown;
this.outcomeKnown = true;
}
if (!outcome)
{
this.AbortInnerContexts();
}
if (this.channel.ContainsRequest(this.requestSequenceNumber))
{
Exception e = new ProtocolException(SR.GetString(SR.ReliableRequestContextAborted));
this.channel.session.OnLocalFault(e, (Message)null, null);
}
}
protected override IAsyncResult OnBeginReply(Message reply, TimeSpan timeout, AsyncCallback callback, object state)
{
return this.BeginReplyInternal(reply, timeout, callback, state);
}
protected override void OnClose(TimeSpan timeout)
{
// ReliableRequestContext.Close() relies on base.Close() to call reply if reply is not initiated.
if (!this.ReplyInitiated)
this.OnReply(null, timeout);
}
protected override void OnEndReply(IAsyncResult result)
{
this.EndReplyInternal(result);
}
protected override void OnReply(Message reply, TimeSpan timeout)
{
this.ReplyInternal(reply, timeout);
}
internal void ReplyInternal(Message reply, TimeSpan timeout)
{
bool needAbort = true;
try
{
lock (this.ThisLock)
{
if (this.ranges == null)
{
throw Fx.AssertAndThrow("this.ranges != null");
}
if (this.Aborted)
{
needAbort = false;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationObjectAbortedException(SR.GetString(SR.RequestContextAborted)));
}
if (this.outcomeKnown)
{
needAbort = false;
return;
}
if ((reply != null) && (this.bufferedReply == null))
this.bufferedReply = reply.CreateBufferedCopy(int.MaxValue);
if (!this.channel.PrepareReply(this))
{
needAbort = false;
return;
}
this.outcomeKnown = true;
}
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
for (int i = 0; i < this.innerContexts.Count; i++)
SendReply(this.innerContexts[i], MaskingMode.Handled, ref timeoutHelper);
this.innerContexts.Clear();
needAbort = false;
}
finally
{
if (needAbort)
{
this.AbortInnerContexts();
this.Abort();
}
}
}
public void SetAckRanges(SequenceRangeCollection ranges)
{
if (this.ranges == null)
this.ranges = ranges;
}
public void SetLastReply(Int64 sequenceNumber)
{
this.replySequenceNumber = sequenceNumber;
this.isLastReply = true;
if (this.bufferedReply == null)
this.bufferedReply = Message.CreateMessage(this.channel.MessageVersion, WsrmFeb2005Strings.LastMessageAction).CreateBufferedCopy(int.MaxValue);
}
public void SendReply(RequestContext context, MaskingMode maskingMode)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(this.DefaultSendTimeout);
SendReply(context, maskingMode, ref timeoutHelper);
}
void SendReply(RequestContext context, MaskingMode maskingMode, ref TimeoutHelper timeoutHelper)
{
Message reply;
if (!this.outcomeKnown)
{
throw Fx.AssertAndThrow("this.outcomeKnown");
}
if (this.bufferedReply != null)
{
reply = this.bufferedReply.CreateMessage();
this.channel.PrepareReplyMessage(this.replySequenceNumber, this.isLastReply, this.ranges, reply);
}
else
{
reply = this.channel.CreateAcknowledgement(this.ranges);
}
this.channel.binder.SetMaskingMode(context, maskingMode);
using (reply)
{
context.Reply(reply, timeoutHelper.RemainingTime());
}
context.Close(timeoutHelper.RemainingTime());
}
public void SetReplySequenceNumber(Int64 sequenceNumber)
{
this.replySequenceNumber = sequenceNumber;
}
class ReplyCompletedAsyncResult : CompletedAsyncResult
{
public ReplyCompletedAsyncResult(AsyncCallback callback, object state)
: base(callback, state)
{
}
}
class ReplyAsyncResult : AsyncResult
{
ReliableRequestContext context;
int currentContext;
Message reply;
TimeoutHelper timeoutHelper;
static AsyncCallback replyCompleteStatic = Fx.ThunkCallback(new AsyncCallback(ReplyCompleteStatic));
public ReplyAsyncResult(ReliableRequestContext thisContext, TimeSpan timeout, AsyncCallback callback, object state)
: base(callback, state)
{
this.timeoutHelper = new TimeoutHelper(timeout);
this.context = thisContext;
if (this.SendReplies())
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End<ReplyAsyncResult>(result);
}
void HandleReplyComplete(IAsyncResult result)
{
RequestContext thisInnerContext = this.context.innerContexts[this.currentContext];
try
{
thisInnerContext.EndReply(result);
thisInnerContext.Close(this.timeoutHelper.RemainingTime());
this.currentContext++;
}
finally
{
this.reply.Close();
this.reply = null;
}
}
static void ReplyCompleteStatic(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
Exception ex = null;
ReplyAsyncResult thisPtr = null;
bool complete = false;
try
{
thisPtr = (ReplyAsyncResult)result.AsyncState;
thisPtr.HandleReplyComplete(result);
complete = thisPtr.SendReplies();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
ex = e;
complete = true;
}
if (complete)
thisPtr.Complete(false, ex);
}
bool SendReplies()
{
while (this.currentContext < this.context.innerContexts.Count)
{
if (this.context.bufferedReply != null)
{
this.reply = this.context.bufferedReply.CreateMessage();
this.context.channel.PrepareReplyMessage(
this.context.replySequenceNumber, this.context.isLastReply,
this.context.ranges, this.reply);
}
else
{
this.reply = this.context.channel.CreateAcknowledgement(this.context.ranges);
}
RequestContext thisInnerContext = this.context.innerContexts[this.currentContext];
this.context.channel.binder.SetMaskingMode(thisInnerContext, MaskingMode.Handled);
IAsyncResult result = thisInnerContext.BeginReply(this.reply, this.timeoutHelper.RemainingTime(), replyCompleteStatic, this);
if (!result.CompletedSynchronously)
return false;
this.HandleReplyComplete(result);
}
return true;
}
}
}
class ReplyHelper
{
Message asyncMessage;
bool canTransfer = true;
ReliableReplySessionChannel channel;
WsrmMessageInfo info;
ReplyProvider replyProvider;
RequestContext requestContext;
bool throwTimeoutOnWait;
InterruptibleWaitObject waitHandle;
internal ReplyHelper(ReliableReplySessionChannel channel, ReplyProvider replyProvider,
bool throwTimeoutOnWait)
{
this.channel = channel;
this.replyProvider = replyProvider;
this.throwTimeoutOnWait = throwTimeoutOnWait;
this.waitHandle = new InterruptibleWaitObject(false, this.throwTimeoutOnWait);
}
object ThisLock
{
get { return this.channel.ThisLock; }
}
internal void Abort()
{
this.Cleanup(true);
}
void Cleanup(bool abort)
{
lock (this.ThisLock)
{
this.canTransfer = false;
}
if (abort)
{
this.waitHandle.Abort(this.channel);
}
else
{
this.waitHandle.Fault(this.channel);
}
}
internal void Fault()
{
this.Cleanup(false);
}
internal void Reply(RequestContext context, WsrmMessageInfo info, TimeSpan timeout, MaskingMode maskingMode)
{
using (Message message = this.replyProvider.Provide(this.channel, info))
{
this.channel.binder.SetMaskingMode(context, maskingMode);
context.Reply(message, timeout);
}
}
IAsyncResult BeginReply(TimeSpan timeout, AsyncCallback callback, object state)
{
lock (this.ThisLock)
{
this.canTransfer = false;
}
if (this.requestContext == null)
{
return new ReplyCompletedAsyncResult(callback, state);
}
this.asyncMessage = this.replyProvider.Provide(this.channel, info);
bool throwing = true;
try
{
this.channel.binder.SetMaskingMode(this.requestContext, MaskingMode.Handled);
IAsyncResult result = this.requestContext.BeginReply(this.asyncMessage, timeout,
callback, state);
throwing = false;
return result;
}
finally
{
if (throwing)
{
this.asyncMessage.Close();
this.asyncMessage = null;
}
}
}
void EndReply(IAsyncResult result)
{
ReplyCompletedAsyncResult completedResult = result as ReplyCompletedAsyncResult;
if (completedResult != null)
{
completedResult.End();
return;
}
try
{
this.requestContext.EndReply(result);
}
finally
{
if (this.asyncMessage != null)
{
this.asyncMessage.Close();
}
}
}
internal bool TransferRequestContext(RequestContext requestContext, WsrmMessageInfo info)
{
RequestContext oldContext = null;
WsrmMessageInfo oldInfo = null;
lock (this.ThisLock)
{
if (!this.canTransfer)
{
return false;
}
else
{
oldContext = this.requestContext;
oldInfo = this.info;
this.requestContext = requestContext;
this.info = info;
}
}
this.waitHandle.Set();
if (oldContext != null)
{
oldInfo.Message.Close();
oldContext.Close();
}
return true;
}
internal void UnblockWaiter()
{
this.TransferRequestContext(null, null);
}
internal void WaitAndReply(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.waitHandle.Wait(timeoutHelper.RemainingTime());
lock (this.ThisLock)
{
this.canTransfer = false;
if (this.requestContext == null)
{
return;
}
}
this.Reply(this.requestContext, this.info, timeoutHelper.RemainingTime(),
MaskingMode.Handled);
}
internal IAsyncResult BeginWaitAndReply(TimeSpan timeout, AsyncCallback callback, object state)
{
OperationWithTimeoutBeginCallback[] beginOperations = new OperationWithTimeoutBeginCallback[] {
new OperationWithTimeoutBeginCallback (this.waitHandle.BeginWait),
new OperationWithTimeoutBeginCallback (this.BeginReply),
};
OperationEndCallback[] endOperations = new OperationEndCallback[] {
new OperationEndCallback (this.waitHandle.EndWait),
new OperationEndCallback(this.EndReply),
};
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout, beginOperations,
endOperations, callback, state);
}
internal void EndWaitAndReply(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
class ReplyCompletedAsyncResult : CompletedAsyncResult
{
internal ReplyCompletedAsyncResult(AsyncCallback callback, object state)
: base(callback, state)
{
}
public void End()
{
AsyncResult.End<ReplyCompletedAsyncResult>(this);
}
}
}
abstract class ReplyProvider
{
internal abstract Message Provide(ReliableReplySessionChannel channel, WsrmMessageInfo info);
}
class CloseSequenceReplyProvider : ReplyProvider
{
static CloseSequenceReplyProvider instance = new CloseSequenceReplyProvider();
CloseSequenceReplyProvider()
{
}
static internal ReplyProvider Instance
{
get
{
if (instance == null)
{
instance = new CloseSequenceReplyProvider();
}
return instance;
}
}
internal override Message Provide(ReliableReplySessionChannel channel, WsrmMessageInfo requestInfo)
{
Message message = WsrmUtilities.CreateCloseSequenceResponse(channel.MessageVersion,
requestInfo.CloseSequenceInfo.MessageId, channel.session.InputID);
channel.AddAcknowledgementHeader(message);
return message;
}
}
class TerminateSequenceReplyProvider : ReplyProvider
{
static TerminateSequenceReplyProvider instance = new TerminateSequenceReplyProvider();
TerminateSequenceReplyProvider()
{
}
static internal ReplyProvider Instance
{
get
{
if (instance == null)
{
instance = new TerminateSequenceReplyProvider();
}
return instance;
}
}
internal override Message Provide(ReliableReplySessionChannel channel, WsrmMessageInfo requestInfo)
{
Message message = WsrmUtilities.CreateTerminateResponseMessage(channel.MessageVersion,
requestInfo.TerminateSequenceInfo.MessageId, channel.session.InputID);
channel.AddAcknowledgementHeader(message);
return message;
}
}
}
}