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

1966 lines
73 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Diagnostics.Application;
using System.Threading;
using System.Xml;
abstract class ReliableDuplexSessionChannel : DuplexChannel, IDuplexSessionChannel
{
bool acknowledgementScheduled = false;
IOThreadTimer acknowledgementTimer;
UInt64 ackVersion = 1;
bool advertisedZero = false;
IReliableChannelBinder binder;
InterruptibleWaitObject closeOutputWaitObject;
SendWaitReliableRequestor closeRequestor;
DeliveryStrategy<Message> deliveryStrategy;
Guard guard = new Guard(Int32.MaxValue);
ReliableInputConnection inputConnection;
Exception maxRetryCountException = null;
static AsyncCallback onReceiveCompleted = Fx.ThunkCallback(new AsyncCallback(OnReceiveCompletedStatic));
ReliableOutputConnection outputConnection;
int pendingAcknowledgements = 0;
ChannelReliableSession session;
IReliableFactorySettings settings;
SendWaitReliableRequestor terminateRequestor;
static Action<object> asyncReceiveComplete = new Action<object>(AsyncReceiveCompleteStatic);
protected ReliableDuplexSessionChannel(ChannelManagerBase manager, IReliableFactorySettings settings, IReliableChannelBinder binder)
: base(manager, binder.LocalAddress)
{
this.binder = binder;
this.settings = settings;
this.acknowledgementTimer = new IOThreadTimer(new Action<object>(this.OnAcknowledgementTimeoutElapsed), null, true);
this.binder.Faulted += OnBinderFaulted;
this.binder.OnException += OnBinderException;
}
public IReliableChannelBinder Binder
{
get { return this.binder; }
}
public override EndpointAddress LocalAddress
{
get { return this.binder.LocalAddress; }
}
protected ReliableOutputConnection OutputConnection
{
get { return this.outputConnection; }
}
protected UniqueId OutputID
{
get { return this.session.OutputID; }
}
protected ChannelReliableSession ReliableSession
{
get { return this.session; }
}
public override EndpointAddress RemoteAddress
{
get { return this.binder.RemoteAddress; }
}
protected IReliableFactorySettings Settings
{
get { return this.settings; }
}
public override Uri Via
{
get { return this.RemoteAddress.Uri; }
}
public IDuplexSession Session
{
get { return (IDuplexSession)this.session; }
}
void AddPendingAcknowledgements(Message message)
{
lock (this.ThisLock)
{
if (this.pendingAcknowledgements > 0)
{
this.acknowledgementTimer.Cancel();
this.acknowledgementScheduled = false;
this.pendingAcknowledgements = 0;
this.ackVersion++;
int bufferRemaining = this.GetBufferRemaining();
WsrmUtilities.AddAcknowledgementHeader(
this.settings.ReliableMessagingVersion,
message,
this.session.InputID,
this.inputConnection.Ranges,
this.inputConnection.IsLastKnown,
bufferRemaining);
}
}
}
IAsyncResult BeginCloseBinder(TimeSpan timeout, AsyncCallback callback,
object state)
{
return this.binder.BeginClose(timeout, MaskingMode.Handled, callback, state);
}
void CloseSequence(TimeSpan timeout)
{
this.CreateCloseRequestor();
this.closeRequestor.Request(timeout);
// reply came from receive loop, receive loop owns verified message so nothing more to do.
}
IAsyncResult BeginCloseSequence(TimeSpan timeout, AsyncCallback callback, object state)
{
this.CreateCloseRequestor();
return this.closeRequestor.BeginRequest(timeout, callback, state);
}
void EndCloseSequence(IAsyncResult result)
{
this.closeRequestor.EndRequest(result);
// reply came from receive loop, receive loop owns verified message so nothing more to do.
}
void ConfigureRequestor(ReliableRequestor requestor)
{
requestor.MessageVersion = this.settings.MessageVersion;
requestor.Binder = this.binder;
requestor.SetRequestResponsePattern();
}
Message CreateAcknowledgmentMessage()
{
lock (this.ThisLock)
this.ackVersion++;
int bufferRemaining = this.GetBufferRemaining();
Message message = WsrmUtilities.CreateAcknowledgmentMessage(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.session.InputID, this.inputConnection.Ranges,
this.inputConnection.IsLastKnown, bufferRemaining);
if (TD.SequenceAcknowledgementSentIsEnabled())
{
TD.SequenceAcknowledgementSent(this.session.Id);
}
return message;
}
void CreateCloseRequestor()
{
SendWaitReliableRequestor temp = new SendWaitReliableRequestor();
this.ConfigureRequestor(temp);
temp.TimeoutString1Index = SR.TimeoutOnClose;
temp.MessageAction = WsrmIndex.GetCloseSequenceActionHeader(
this.settings.MessageVersion.Addressing);
temp.MessageBody = new CloseSequence(this.session.OutputID, this.outputConnection.Last);
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.closeRequestor = temp;
}
}
void CreateTerminateRequestor()
{
SendWaitReliableRequestor temp = new SendWaitReliableRequestor();
this.ConfigureRequestor(temp);
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
temp.MessageAction = WsrmIndex.GetTerminateSequenceActionHeader(
this.settings.MessageVersion.Addressing, reliableMessagingVersion);
temp.MessageBody = new TerminateSequence(reliableMessagingVersion, this.session.OutputID,
this.outputConnection.Last);
lock (this.ThisLock)
{
this.ThrowIfClosed();
this.terminateRequestor = temp;
if (this.inputConnection.IsLastKnown)
{
this.session.CloseSession();
}
}
}
void EndCloseBinder(IAsyncResult result)
{
this.binder.EndClose(result);
}
int GetBufferRemaining()
{
int bufferRemaining = -1;
if (this.settings.FlowControlEnabled)
{
bufferRemaining = this.settings.MaxTransferWindowSize - this.deliveryStrategy.EnqueuedCount;
this.advertisedZero = (bufferRemaining == 0);
}
return bufferRemaining;
}
public override T GetProperty<T>()
{
if (typeof(T) == typeof(IDuplexSessionChannel))
{
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.settings.MessageVersion);
}
else
{
return innerProperty;
}
}
void InternalCloseOutputSession(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.outputConnection.Close(timeoutHelper.RemainingTime());
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
this.CloseSequence(timeoutHelper.RemainingTime());
}
this.TerminateSequence(timeoutHelper.RemainingTime());
}
IAsyncResult BeginInternalCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
{
bool wsrm11 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
OperationWithTimeoutBeginCallback[] beginOperations = new OperationWithTimeoutBeginCallback[] {
this.outputConnection.BeginClose,
wsrm11 ? this.BeginCloseSequence : default(OperationWithTimeoutBeginCallback),
this.BeginTerminateSequence };
OperationEndCallback[] endOperations = new OperationEndCallback[] {
this.outputConnection.EndClose,
wsrm11 ? this.EndCloseSequence : default(OperationEndCallback),
this.EndTerminateSequence };
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout,
beginOperations, endOperations, callback, state);
}
void EndInternalCloseOutputSession(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
protected virtual void OnRemoteActivity()
{
this.session.OnRemoteActivity(false);
}
WsrmFault ProcessCloseOrTerminateSequenceResponse(bool close, WsrmMessageInfo info)
{
SendWaitReliableRequestor requestor = close ? this.closeRequestor : this.terminateRequestor;
if (requestor != null)
{
WsrmFault fault = close
? WsrmUtilities.ValidateCloseSequenceResponse(this.session, this.closeRequestor.MessageId, info,
this.outputConnection.Last)
: WsrmUtilities.ValidateTerminateSequenceResponse(this.session, this.terminateRequestor.MessageId,
info, this.outputConnection.Last);
if (fault != null)
{
return fault;
}
requestor.SetInfo(info);
return null;
}
string request = close ? Wsrm11Strings.CloseSequence : WsrmFeb2005Strings.TerminateSequence;
string faultString = SR.GetString(SR.ReceivedResponseBeforeRequestFaultString, request);
string exceptionString = SR.GetString(SR.ReceivedResponseBeforeRequestExceptionString, request);
return SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultString, exceptionString);
}
protected void ProcessDuplexMessage(WsrmMessageInfo info)
{
bool closeMessage = true;
try
{
bool wsrmFeb2005 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
bool final = false;
if (this.outputConnection != null && info.AcknowledgementInfo != null)
{
final = wsrm11 && info.AcknowledgementInfo.Final;
int bufferRemaining = -1;
if (this.settings.FlowControlEnabled)
bufferRemaining = info.AcknowledgementInfo.BufferRemaining;
this.outputConnection.ProcessTransferred(info.AcknowledgementInfo.Ranges, bufferRemaining);
}
this.OnRemoteActivity();
bool tryAckNow = (info.AckRequestedInfo != null);
bool forceAck = false;
bool terminate = false;
bool scheduleShutdown = false;
UInt64 oldAckVersion = 0;
WsrmFault fault = null;
Message message = null;
Exception remoteFaultException = null;
if (info.SequencedMessageInfo != null)
{
bool needDispatch = false;
lock (this.ThisLock)
{
if (this.Aborted || this.State == CommunicationState.Faulted)
{
return;
}
Int64 sequenceNumber = info.SequencedMessageInfo.SequenceNumber;
bool isLast = wsrmFeb2005 && info.SequencedMessageInfo.LastMessage;
if (!this.inputConnection.IsValid(sequenceNumber, isLast))
{
if (wsrmFeb2005)
{
fault = new LastMessageNumberExceededFault(this.ReliableSession.InputID);
}
else
{
message = new SequenceClosedFault(this.session.InputID).CreateMessage(
this.settings.MessageVersion, this.settings.ReliableMessagingVersion);
forceAck = true;
this.OnMessageDropped();
}
}
else if (this.inputConnection.Ranges.Contains(sequenceNumber))
{
this.OnMessageDropped();
tryAckNow = true;
}
else if (wsrmFeb2005 && info.Action == WsrmFeb2005Strings.LastMessageAction)
{
this.inputConnection.Merge(sequenceNumber, isLast);
if (this.inputConnection.AllAdded)
{
scheduleShutdown = true;
if (this.outputConnection.CheckForTermination())
{
this.session.CloseSession();
}
}
}
else if (this.State == CommunicationState.Closing)
{
if (wsrmFeb2005)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone),
SR.GetString(SR.SessionClosedBeforeDone));
}
else
{
message = new SequenceClosedFault(this.session.InputID).CreateMessage(
this.settings.MessageVersion, this.settings.ReliableMessagingVersion);
forceAck = true;
this.OnMessageDropped();
}
}
// 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(sequenceNumber)
&& (this.Settings.Ordered || this.inputConnection.CanMerge(sequenceNumber)))
{
this.inputConnection.Merge(sequenceNumber, isLast);
needDispatch = this.deliveryStrategy.Enqueue(info.Message, sequenceNumber);
closeMessage = false;
oldAckVersion = this.ackVersion;
this.pendingAcknowledgements++;
if (this.inputConnection.AllAdded)
{
scheduleShutdown = true;
if (this.outputConnection.CheckForTermination())
{
this.session.CloseSession();
}
}
}
else
{
this.OnMessageDropped();
}
// if (ack now && we enqueued && an ack has been sent since we enqueued (and thus
// carries the sequence number of the message we just processed)) then we don't
// need to ack again.
if (this.inputConnection.IsLastKnown || this.pendingAcknowledgements == this.settings.MaxTransferWindowSize)
tryAckNow = true;
bool startTimer = tryAckNow || (this.pendingAcknowledgements > 0 && fault == null);
if (startTimer && !this.acknowledgementScheduled)
{
this.acknowledgementScheduled = true;
this.acknowledgementTimer.Set(this.settings.AcknowledgementInterval);
}
}
if (needDispatch)
{
this.Dispatch();
}
}
else if (wsrmFeb2005 && info.TerminateSequenceInfo != null)
{
bool isTerminateEarly;
lock (this.ThisLock)
{
isTerminateEarly = !this.inputConnection.Terminate();
}
if (isTerminateEarly)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedEarlyTerminateSequence),
SR.GetString(SR.EarlyTerminateSequence));
}
}
else if (wsrm11)
{
if (((info.TerminateSequenceInfo != null) && (info.TerminateSequenceInfo.Identifier == this.session.InputID))
|| (info.CloseSequenceInfo != null))
{
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, null))
{
return;
}
bool isLastLargeEnough = true;
bool isLastConsistent = true;
lock (this.ThisLock)
{
if (!this.inputConnection.IsLastKnown)
{
if (isTerminate)
{
if (this.inputConnection.SetTerminateSequenceLast(last, out isLastLargeEnough))
{
scheduleShutdown = true;
}
else if (isLastLargeEnough)
{
remoteFaultException = new ProtocolException(SR.GetString(SR.EarlyTerminateSequence));
}
}
else
{
scheduleShutdown = this.inputConnection.SetCloseSequenceLast(last);
isLastLargeEnough = scheduleShutdown;
}
if (scheduleShutdown)
{
this.session.SetFinalAck(this.inputConnection.Ranges);
if (this.terminateRequestor != null)
{
this.session.CloseSession();
}
this.deliveryStrategy.Dispose();
}
}
else
{
isLastConsistent = (last == this.inputConnection.Last);
// Have seen CloseSequence already, TerminateSequence means cleanup.
if (isTerminate && isLastConsistent && this.inputConnection.IsSequenceClosed)
{
terminate = true;
}
}
}
if (!isLastLargeEnough)
{
string faultString = SR.GetString(SR.SequenceTerminatedSmallLastMsgNumber);
string exceptionString = SR.GetString(SR.SmallLastMsgNumberExceptionString);
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID, 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
{
message = isTerminate
? WsrmUtilities.CreateTerminateResponseMessage(this.settings.MessageVersion,
requestInfo.MessageId, this.session.InputID)
: WsrmUtilities.CreateCloseSequenceResponse(this.settings.MessageVersion,
requestInfo.MessageId, this.session.InputID);
forceAck = true;
}
}
else if (info.TerminateSequenceInfo != null) // Identifier == OutputID
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedUnsupportedTerminateSequence),
SR.GetString(SR.UnsupportedTerminateSequenceExceptionString));
}
else if (info.TerminateSequenceResponseInfo != null)
{
fault = this.ProcessCloseOrTerminateSequenceResponse(false, info);
}
else if (info.CloseSequenceResponseInfo != null)
{
fault = this.ProcessCloseOrTerminateSequenceResponse(true, info);
}
else if (final)
{
if (this.closeRequestor == null)
{
string exceptionString = SR.GetString(SR.UnsupportedCloseExceptionString);
string faultString = SR.GetString(SR.SequenceTerminatedUnsupportedClose);
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultString,
exceptionString);
}
else
{
fault = WsrmUtilities.ValidateFinalAck(this.session, info, this.outputConnection.Last);
if (fault == null)
{
this.closeRequestor.SetInfo(info);
}
}
}
else if (info.WsrmHeaderFault != null)
{
if (!(info.WsrmHeaderFault is UnknownSequenceFault))
{
throw Fx.AssertAndThrow("Fault must be UnknownSequence fault.");
}
if (this.terminateRequestor == null)
{
throw Fx.AssertAndThrow("In wsrm11, if we start getting UnknownSequence, terminateRequestor cannot be null.");
}
this.terminateRequestor.SetInfo(info);
}
}
if (fault != null)
{
this.session.OnLocalFault(fault.CreateException(), fault, null);
return;
}
if (scheduleShutdown)
{
ActionItem.Schedule(this.ShutdownCallback, null);
}
if (message != null)
{
if (forceAck)
{
WsrmUtilities.AddAcknowledgementHeader(this.settings.ReliableMessagingVersion, message,
this.session.InputID, this.inputConnection.Ranges, true, this.GetBufferRemaining());
}
else if (tryAckNow)
{
this.AddPendingAcknowledgements(message);
}
}
else if (tryAckNow)
{
lock (this.ThisLock)
{
if (oldAckVersion != 0 && oldAckVersion != this.ackVersion)
return;
if (this.acknowledgementScheduled)
{
this.acknowledgementTimer.Cancel();
this.acknowledgementScheduled = false;
}
this.pendingAcknowledgements = 0;
}
message = this.CreateAcknowledgmentMessage();
}
if (message != null)
{
using (message)
{
if (this.guard.Enter())
{
try
{
this.binder.Send(message, this.DefaultSendTimeout);
}
finally
{
this.guard.Exit();
}
}
}
}
if (terminate)
{
lock (this.ThisLock)
{
this.inputConnection.Terminate();
}
}
if (remoteFaultException != null)
{
this.ReliableSession.OnRemoteFault(remoteFaultException);
}
}
finally
{
if (closeMessage)
{
info.Message.Close();
}
}
}
protected abstract void ProcessMessage(WsrmMessageInfo info);
protected override void OnAbort()
{
if (this.outputConnection != null)
this.outputConnection.Abort(this);
if (this.inputConnection != null)
this.inputConnection.Abort(this);
this.guard.Abort();
ReliableRequestor tempRequestor = this.closeRequestor;
if (tempRequestor != null)
{
tempRequestor.Abort(this);
}
tempRequestor = this.terminateRequestor;
if (tempRequestor != null)
{
tempRequestor.Abort(this);
}
this.session.Abort();
}
void OnAcknowledgementTimeoutElapsed(object state)
{
lock (this.ThisLock)
{
this.acknowledgementScheduled = false;
this.pendingAcknowledgements = 0;
if (this.State == CommunicationState.Closing
|| this.State == CommunicationState.Closed
|| this.State == CommunicationState.Faulted)
return;
}
if (this.guard.Enter())
{
try
{
using (Message message = CreateAcknowledgmentMessage())
{
this.binder.Send(message, this.DefaultSendTimeout);
}
}
finally
{
this.guard.Exit();
}
}
}
protected IAsyncResult OnBeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
{
bool complete = false;
lock (this.ThisLock)
{
this.ThrowIfNotOpened();
this.ThrowIfFaulted();
if ((this.State != CommunicationState.Opened)
|| (this.closeOutputWaitObject != null))
{
complete = true;
}
else
{
this.closeOutputWaitObject = new InterruptibleWaitObject(false, true);
}
}
if (complete)
{
return new CompletedAsyncResult(callback, state);
}
else
{
bool throwing = true;
try
{
IAsyncResult result = this.BeginInternalCloseOutputSession(timeout, callback,
state);
throwing = false;
return result;
}
finally
{
if (throwing)
{
this.session.OnLocalFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.session.OutputID, SR.GetString(SR.CloseOutputSessionErrorReason), null), null);
this.closeOutputWaitObject.Fault(this);
}
}
}
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfCloseInvalid();
OperationWithTimeoutBeginCallback closeOutputConnectionBeginCallback;
OperationEndCallback closeOutputConnectionEndCallback;
if (this.outputConnection == null)
{
closeOutputConnectionBeginCallback = default(OperationWithTimeoutBeginCallback);
closeOutputConnectionEndCallback = default(OperationEndCallback);
}
else if (this.closeOutputWaitObject == null)
{
closeOutputConnectionBeginCallback = new OperationWithTimeoutBeginCallback(
this.BeginInternalCloseOutputSession);
closeOutputConnectionEndCallback = new OperationEndCallback(
this.EndInternalCloseOutputSession);
}
else
{
closeOutputConnectionBeginCallback = new OperationWithTimeoutBeginCallback(
this.closeOutputWaitObject.BeginWait);
closeOutputConnectionEndCallback = new OperationEndCallback(
this.closeOutputWaitObject.EndWait);
}
OperationWithTimeoutBeginCallback closeInputConnectionBeginCallback;
OperationEndCallback closeInputConnectionEndCallback;
if (this.inputConnection == null)
{
closeInputConnectionBeginCallback = default(OperationWithTimeoutBeginCallback);
closeInputConnectionEndCallback = default(OperationEndCallback);
}
else
{
closeInputConnectionBeginCallback = new OperationWithTimeoutBeginCallback(
this.inputConnection.BeginClose);
closeInputConnectionEndCallback = new OperationEndCallback(
this.inputConnection.EndClose);
}
OperationWithTimeoutBeginCallback[] beginOperations;
OperationEndCallback[] endOperations;
beginOperations = new OperationWithTimeoutBeginCallback[]
{
closeOutputConnectionBeginCallback,
closeInputConnectionBeginCallback,
this.guard.BeginClose,
this.session.BeginClose,
this.BeginCloseBinder,
base.OnBeginClose
};
endOperations = new OperationEndCallback[]
{
closeOutputConnectionEndCallback,
closeInputConnectionEndCallback,
this.guard.EndClose,
this.session.EndClose,
this.EndCloseBinder,
base.OnEndClose
};
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout,
beginOperations, endOperations, callback, state);
}
protected override IAsyncResult OnBeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
{
return this.outputConnection.BeginAddMessage(message, timeout, null, callback, state);
}
IAsyncResult OnBeginSendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException, AsyncCallback callback, object state)
{
if (attemptInfo.RetryCount > this.settings.MaxRetryCount)
{
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.AddPendingAcknowledgements(attemptInfo.Message);
ReliableBinderSendAsyncResult result = new ReliableBinderSendAsyncResult(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;
}
}
IAsyncResult OnBeginSendAckRequestedHandler(TimeSpan timeout, AsyncCallback callback, object state)
{
this.session.OnLocalActivity();
ReliableBinderSendAsyncResult sendResult = new ReliableBinderSendAsyncResult(callback, state);
sendResult.Binder = this.binder;
sendResult.MaskingMode = MaskingMode.Handled;
sendResult.Message = WsrmUtilities.CreateAckRequestedMessage(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.ReliableSession.OutputID);
sendResult.Begin(timeout);
return sendResult;
}
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.EnqueueAndDispatch(exception, null, false);
}
}
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);
}
}
// CloseOutputSession && Close: CloseOutputSession only closes the ReliableOutputConnection
// from the Opened state, if it does, it must create the closeOutputWaitObject so that
// close may properly synchronize. If no closeOutputWaitObject is present, Close may close
// the ---- safely since it is in the Closing state.
protected override void OnClose(TimeSpan timeout)
{
this.ThrowIfCloseInvalid();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (this.outputConnection != null)
{
if (this.closeOutputWaitObject != null)
{
this.closeOutputWaitObject.Wait(timeoutHelper.RemainingTime());
}
else
{
this.InternalCloseOutputSession(timeoutHelper.RemainingTime());
}
this.inputConnection.Close(timeoutHelper.RemainingTime());
}
this.guard.Close(timeoutHelper.RemainingTime());
this.session.Close(timeoutHelper.RemainingTime());
this.binder.Close(timeoutHelper.RemainingTime(), MaskingMode.Handled);
base.OnClose(timeoutHelper.RemainingTime());
}
protected void OnCloseOutputSession(TimeSpan timeout)
{
lock (this.ThisLock)
{
this.ThrowIfNotOpened();
this.ThrowIfFaulted();
if ((this.State != CommunicationState.Opened)
|| (this.closeOutputWaitObject != null))
{
return;
}
this.closeOutputWaitObject = new InterruptibleWaitObject(false, true);
}
bool throwing = true;
try
{
this.InternalCloseOutputSession(timeout);
throwing = false;
}
finally
{
if (throwing)
{
this.session.OnLocalFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.session.OutputID, SR.GetString(SR.CloseOutputSessionErrorReason), null), null);
this.closeOutputWaitObject.Fault(this);
}
else
{
this.closeOutputWaitObject.Set();
}
}
}
protected override void OnClosed()
{
base.OnClosed();
this.binder.Faulted -= this.OnBinderFaulted;
if (this.deliveryStrategy != null)
this.deliveryStrategy.Dispose();
}
protected override void OnClosing()
{
base.OnClosing();
this.acknowledgementTimer.Cancel();
}
void OnComponentFaulted(Exception faultException, WsrmFault fault)
{
this.session.OnLocalFault(faultException, fault, null);
}
void OnComponentException(Exception exception)
{
this.ReliableSession.OnUnknownException(exception);
}
protected override void OnEndClose(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
protected void OnEndCloseOutputSession(IAsyncResult result)
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
}
else
{
bool throwing = true;
try
{
this.EndInternalCloseOutputSession(result);
throwing = false;
}
finally
{
if (throwing)
{
this.session.OnLocalFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.session.OutputID, SR.GetString(SR.CloseOutputSessionErrorReason), null), null);
this.closeOutputWaitObject.Fault(this);
}
else
{
this.closeOutputWaitObject.Set();
}
}
}
}
protected override void OnEndSend(IAsyncResult result)
{
if (!this.outputConnection.EndAddMessage(result))
this.ThrowInvalidAddException();
}
void OnEndSendHandler(IAsyncResult result)
{
if (result is CompletedAsyncResult)
{
CompletedAsyncResult.End(result);
}
else
{
Exception handledException;
ReliableBinderSendAsyncResult.End(result, out handledException);
ReliableBinderSendAsyncResult sendResult = (ReliableBinderSendAsyncResult)result;
if (sendResult.MessageAttemptInfo.RetryCount == this.settings.MaxRetryCount)
{
this.maxRetryCountException = handledException;
}
}
}
void OnEndSendAckRequestedHandler(IAsyncResult result)
{
ReliableBinderSendAsyncResult.End(result);
}
protected override void OnFaulted()
{
this.session.OnFaulted();
this.UnblockClose();
base.OnFaulted();
}
protected override void OnSend(Message message, TimeSpan timeout)
{
if (!this.outputConnection.AddMessage(message, timeout, null))
this.ThrowInvalidAddException();
}
void OnSendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException)
{
using (attemptInfo.Message)
{
if (attemptInfo.RetryCount > this.settings.MaxRetryCount)
{
this.session.OnLocalFault(new CommunicationException(SR.GetString(SR.MaximumRetryCountExceeded), this.maxRetryCountException),
SequenceTerminatedFault.CreateMaxRetryCountExceededFault(this.session.OutputID), null);
}
else
{
this.session.OnLocalActivity();
this.AddPendingAcknowledgements(attemptInfo.Message);
MaskingMode maskingMode = maskUnhandledException ? MaskingMode.Unhandled : MaskingMode.None;
if (attemptInfo.RetryCount < this.settings.MaxRetryCount)
{
maskingMode |= MaskingMode.Handled;
this.binder.Send(attemptInfo.Message, timeout, maskingMode);
}
else
{
try
{
this.binder.Send(attemptInfo.Message, timeout, maskingMode);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (this.binder.IsHandleable(e))
{
this.maxRetryCountException = e;
}
else
{
throw;
}
}
}
}
}
}
void OnSendAckRequestedHandler(TimeSpan timeout)
{
this.session.OnLocalActivity();
using (Message message = WsrmUtilities.CreateAckRequestedMessage(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.ReliableSession.OutputID))
{
this.binder.Send(message, timeout, MaskingMode.Handled);
}
}
static void OnReceiveCompletedStatic(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
ReliableDuplexSessionChannel channel = (ReliableDuplexSessionChannel)(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.ReliableSession.OnUnknownException(e);
}
}
static void AsyncReceiveCompleteStatic(object state)
{
IAsyncResult result = (IAsyncResult)state;
ReliableDuplexSessionChannel channel = (ReliableDuplexSessionChannel)(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.ReliableSession.OnUnknownException(e);
}
}
bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
if (this.Binder.EndTryReceive(result, out context))
{
if (context == null)
{
bool terminated = false;
lock (this.ThisLock)
{
terminated = this.inputConnection.Terminate();
}
if (!terminated && (this.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(SR.GetString(SR.EarlySecurityClose));
this.ReliableSession.OnLocalFault(e, (Message)null, null);
}
return false;
}
Message message = context.RequestMessage;
context.Close();
WsrmMessageInfo info = WsrmMessageInfo.Get(this.settings.MessageVersion,
this.settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(),
message);
this.StartReceiving(false);
this.ProcessMessage(info);
return false;
}
return true;
}
protected override void OnOpened()
{
base.OnOpened();
}
protected virtual void OnMessageDropped()
{
}
protected void SetConnections()
{
this.outputConnection = new ReliableOutputConnection(this.session.OutputID,
this.settings.MaxTransferWindowSize, this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.session.InitiationTime, true, this.DefaultSendTimeout);
this.outputConnection.Faulted += OnComponentFaulted;
this.outputConnection.OnException += OnComponentException;
this.outputConnection.BeginSendHandler = OnBeginSendHandler;
this.outputConnection.EndSendHandler = OnEndSendHandler;
this.outputConnection.SendHandler = OnSendHandler;
this.outputConnection.BeginSendAckRequestedHandler = OnBeginSendAckRequestedHandler;
this.outputConnection.EndSendAckRequestedHandler = OnEndSendAckRequestedHandler;
this.outputConnection.SendAckRequestedHandler = OnSendAckRequestedHandler;
this.inputConnection = new ReliableInputConnection();
this.inputConnection.ReliableMessagingVersion = this.Settings.ReliableMessagingVersion;
if (this.settings.Ordered)
this.deliveryStrategy = new OrderedDeliveryStrategy<Message>(this, this.settings.MaxTransferWindowSize, false);
else
this.deliveryStrategy = new UnorderedDeliveryStrategy<Message>(this, this.settings.MaxTransferWindowSize);
this.deliveryStrategy.DequeueCallback = this.OnDeliveryStrategyItemDequeued;
}
protected void SetSession(ChannelReliableSession session)
{
session.UnblockChannelCloseCallback = this.UnblockClose;
this.session = session;
}
void OnDeliveryStrategyItemDequeued()
{
if (this.advertisedZero)
this.OnAcknowledgementTimeoutElapsed(null);
}
protected 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)
{
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.outputConnection.CheckForTermination())
{
this.session.CloseSession();
}
Message message = WsrmUtilities.CreateTerminateMessage(this.settings.MessageVersion,
reliableMessagingVersion, this.session.OutputID);
this.binder.Send(message, timeout, MaskingMode.Handled);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
this.CreateTerminateRequestor();
this.terminateRequestor.Request(timeout);
// reply came from receive loop, receive loop owns verified message so nothing more to do.
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
IAsyncResult BeginTerminateSequence(TimeSpan timeout, AsyncCallback callback, object state)
{
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.outputConnection.CheckForTermination())
{
this.session.CloseSession();
}
Message message = WsrmUtilities.CreateTerminateMessage(this.settings.MessageVersion,
reliableMessagingVersion, this.session.OutputID);
return this.binder.BeginSend(message, timeout, MaskingMode.Handled, callback, state);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
this.CreateTerminateRequestor();
return this.terminateRequestor.BeginRequest(timeout, callback, state);
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
void EndTerminateSequence(IAsyncResult result)
{
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
this.binder.EndSend(result);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
this.terminateRequestor.EndRequest(result);
// reply came from receive loop, receive loop owns verified message so nothing more to do.
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
void ThrowIfCloseInvalid()
{
bool shouldFault = false;
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.deliveryStrategy.EnqueuedCount > 0 || this.inputConnection.Ranges.Count > 1)
{
shouldFault = true;
}
}
else if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.deliveryStrategy.EnqueuedCount > 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 ThrowInvalidAddException()
{
if (this.State == CommunicationState.Opened)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SendCannotBeCalledAfterCloseOutputSession)));
else if (this.State == CommunicationState.Faulted)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.GetTerminalException());
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateClosedException());
}
void UnblockClose()
{
if (this.outputConnection != null)
{
this.outputConnection.Fault(this);
}
if (this.inputConnection != null)
{
this.inputConnection.Fault(this);
}
ReliableRequestor tempRequestor = this.closeRequestor;
if (tempRequestor != null)
{
tempRequestor.Fault(this);
}
tempRequestor = this.terminateRequestor;
if (tempRequestor != null)
{
tempRequestor.Fault(this);
}
}
}
class ClientReliableDuplexSessionChannel : ReliableDuplexSessionChannel
{
ChannelParameterCollection channelParameters;
DuplexClientReliableSession clientSession;
TimeoutHelper closeTimeoutHelper;
bool closing;
static AsyncCallback onReconnectComplete = Fx.ThunkCallback(new AsyncCallback(OnReconnectComplete));
static Action<object> onReconnectTimerElapsed = new Action<object>(OnReconnectTimerElapsed);
public ClientReliableDuplexSessionChannel(ChannelManagerBase factory, IReliableFactorySettings settings,
IReliableChannelBinder binder, FaultHelper faultHelper,
LateBoundChannelParameterCollection channelParameters, UniqueId inputID)
: base(factory, settings, binder)
{
this.clientSession = new DuplexClientReliableSession(this, settings, faultHelper, inputID);
this.clientSession.PollingCallback = this.PollingCallback;
this.SetSession(this.clientSession);
this.channelParameters = channelParameters;
channelParameters.SetChannel(this);
((IClientReliableChannelBinder)binder).ConnectionLost += this.OnConnectionLost;
}
public override T GetProperty<T>()
{
if (typeof(T) == typeof(ChannelParameterCollection))
{
return (T)(object)this.channelParameters;
}
return base.GetProperty<T>();
}
void HandleReconnectComplete(IAsyncResult result)
{
bool handleException = true;
try
{
this.Binder.EndSend(result);
handleException = false;
lock (this.ThisLock)
{
if (this.Binder.Connected)
this.clientSession.ResumePolling(this.OutputConnection.Strategy.QuotaRemaining == 0);
else
this.WaitForReconnect();
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (handleException)
this.WaitForReconnect();
else
throw;
}
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
this.closeTimeoutHelper = new TimeoutHelper(timeout);
this.closing = true;
return base.OnBeginClose(timeout, callback, state);
}
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return new ReliableChannelOpenAsyncResult(this.Binder, this.ReliableSession,
timeout, callback, state);
}
protected override void OnClose(TimeSpan timeout)
{
this.closeTimeoutHelper = new TimeoutHelper(timeout);
this.closing = true;
base.OnClose(timeout);
}
void OnConnectionLost(object sender, EventArgs args)
{
lock (this.ThisLock)
{
if ((this.State == CommunicationState.Opened || this.State == CommunicationState.Closing) &&
!this.Binder.Connected && this.clientSession.StopPolling())
{
if (TD.ClientReliableSessionReconnectIsEnabled())
{
TD.ClientReliableSessionReconnect(this.clientSession.Id);
}
this.Reconnect();
}
}
}
protected override void OnEndOpen(IAsyncResult result)
{
ReliableChannelOpenAsyncResult.End(result);
}
protected override void OnOpen(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
bool throwing = true;
try
{
this.Binder.Open(timeoutHelper.RemainingTime());
this.ReliableSession.Open(timeoutHelper.RemainingTime());
throwing = false;
}
finally
{
if (throwing)
{
this.Binder.Close(timeoutHelper.RemainingTime());
}
}
}
protected override void OnOpened()
{
base.OnOpened();
this.SetConnections();
if (Thread.CurrentThread.IsThreadPoolThread)
{
try
{
this.StartReceiving(false);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
this.ReliableSession.OnUnknownException(e);
}
}
else
{
ActionItem.Schedule(new Action<object>(StartReceivingStatic), this);
}
}
static void OnReconnectComplete(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
ClientReliableDuplexSessionChannel channel = (ClientReliableDuplexSessionChannel)result.AsyncState;
channel.HandleReconnectComplete(result);
}
static void OnReconnectTimerElapsed(object state)
{
ClientReliableDuplexSessionChannel channel = (ClientReliableDuplexSessionChannel)state;
lock (channel.ThisLock)
{
if ((channel.State == CommunicationState.Opened || channel.State == CommunicationState.Closing) &&
!channel.Binder.Connected)
{
channel.Reconnect();
}
else
{
channel.clientSession.ResumePolling(channel.OutputConnection.Strategy.QuotaRemaining == 0);
}
}
}
protected override void OnRemoteActivity()
{
this.ReliableSession.OnRemoteActivity(this.OutputConnection.Strategy.QuotaRemaining == 0);
}
void PollingCallback()
{
using (Message message = WsrmUtilities.CreateAckRequestedMessage(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.ReliableSession.OutputID))
{
this.Binder.Send(message, this.DefaultSendTimeout);
}
}
protected override void ProcessMessage(WsrmMessageInfo info)
{
if (!this.ReliableSession.ProcessInfo(info, null))
return;
if (!this.ReliableSession.VerifyDuplexProtocolElements(info, null))
return;
this.ProcessDuplexMessage(info);
}
static void StartReceivingStatic(object state)
{
ClientReliableDuplexSessionChannel channel = (ClientReliableDuplexSessionChannel)state;
try
{
channel.StartReceiving(true);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
channel.ReliableSession.OnUnknownException(e);
}
}
// It is safe to call this in a lock.
void Reconnect()
{
bool handleException = true;
try
{
Message message = WsrmUtilities.CreateAckRequestedMessage(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.ReliableSession.OutputID);
TimeSpan timeout = this.closing ? this.closeTimeoutHelper.RemainingTime() : this.DefaultCloseTimeout;
IAsyncResult result = this.Binder.BeginSend(message, timeout, onReconnectComplete, this);
handleException = false;
if (result.CompletedSynchronously)
this.HandleReconnectComplete(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (handleException)
this.WaitForReconnect();
else
throw;
}
}
// If anything throws out of this method, we'll consider it fatal.
void WaitForReconnect()
{
TimeSpan timeout;
if (this.closing)
timeout = TimeoutHelper.Divide(this.closeTimeoutHelper.RemainingTime(), 2);
else
timeout = TimeoutHelper.Divide(this.DefaultSendTimeout, 2);
IOThreadTimer timer = new IOThreadTimer(onReconnectTimerElapsed, this, false);
timer.Set(timeout);
}
class DuplexClientReliableSession : ClientReliableSession, IDuplexSession
{
ClientReliableDuplexSessionChannel channel;
public DuplexClientReliableSession(ClientReliableDuplexSessionChannel channel,
IReliableFactorySettings settings, FaultHelper helper, UniqueId inputID)
: base(channel, settings, (IClientReliableChannelBinder)channel.Binder, helper, inputID)
{
this.channel = channel;
}
public IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state)
{
return this.BeginCloseOutputSession(this.channel.DefaultCloseTimeout, callback, state);
}
public IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
{
return channel.OnBeginCloseOutputSession(timeout, callback, state);
}
public void EndCloseOutputSession(IAsyncResult result)
{
channel.OnEndCloseOutputSession(result);
}
public void CloseOutputSession()
{
this.CloseOutputSession(this.channel.DefaultCloseTimeout);
}
public void CloseOutputSession(TimeSpan timeout)
{
channel.OnCloseOutputSession(timeout);
}
}
}
sealed class ServerReliableDuplexSessionChannel : ReliableDuplexSessionChannel
{
ReliableChannelListenerBase<IDuplexSessionChannel> listener;
string perfCounterId;
public ServerReliableDuplexSessionChannel(
ReliableChannelListenerBase<IDuplexSessionChannel> listener,
IReliableChannelBinder binder, FaultHelper faultHelper,
UniqueId inputID,
UniqueId outputID)
: base(listener, listener, binder)
{
this.listener = listener;
DuplexServerReliableSession session = new DuplexServerReliableSession(this, listener, faultHelper, inputID, outputID);
this.SetSession(session);
session.Open(TimeSpan.Zero);
this.SetConnections();
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.ReliableSession.OnUnknownException(e);
}
}
}
IAsyncResult BeginUnregisterChannel(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.listener.OnReliableChannelBeginClose(this.ReliableSession.InputID,
this.ReliableSession.OutputID, timeout, callback, state);
}
void EndUnregisterChannel(IAsyncResult result)
{
this.listener.OnReliableChannelEndClose(result);
}
// Close/Abort: The base Close/Abort is called first because it is shutting down the
// channel. Shutting down the server state should be done after shutting down the channel.
protected override void OnAbort()
{
base.OnAbort();
this.listener.OnReliableChannelAbort(this.ReliableSession.InputID,
this.ReliableSession.OutputID);
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback,
object state)
{
OperationWithTimeoutBeginCallback[] beginOperations =
new OperationWithTimeoutBeginCallback[] {
new OperationWithTimeoutBeginCallback(base.OnBeginClose),
new OperationWithTimeoutBeginCallback(this.BeginUnregisterChannel) };
OperationEndCallback[] endOperations =
new OperationEndCallback[] {
new OperationEndCallback(base.OnEndClose),
new OperationEndCallback(this.EndUnregisterChannel) };
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout,
beginOperations, endOperations, callback, state);
}
protected override void OnClose(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
base.OnClose(timeoutHelper.RemainingTime());
this.listener.OnReliableChannelClose(this.ReliableSession.InputID,
this.ReliableSession.OutputID, timeoutHelper.RemainingTime());
}
protected override void OnEndClose(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
protected override void OnOpen(TimeSpan timeout)
{
}
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return new CompletedAsyncResult(callback, state);
}
protected override void OnEndOpen(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected override void OnFaulted()
{
base.OnFaulted();
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.SessionFaulted(this.perfCounterId);
}
protected override void OnMessageDropped()
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
public void ProcessDemuxedMessage(WsrmMessageInfo info)
{
try
{
this.ProcessMessage(info);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
this.ReliableSession.OnUnknownException(e);
}
}
protected override void ProcessMessage(WsrmMessageInfo info)
{
if (!this.ReliableSession.ProcessInfo(info, null))
return;
if (!this.ReliableSession.VerifyDuplexProtocolElements(info, null))
return;
if (info.CreateSequenceInfo != null)
{
EndpointAddress acksTo;
if (WsrmUtilities.ValidateCreateSequence<IDuplexSessionChannel>(info, this.listener, this.Binder.Channel, out acksTo))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, true, info.CreateSequenceInfo, this.Settings.Ordered,
this.ReliableSession.InputID, acksTo);
using (info.Message)
{
using (response)
{
if (((IServerReliableChannelBinder)this.Binder).AddressResponse(info.Message, response))
this.Binder.Send(response, this.DefaultSendTimeout);
}
}
}
else
{
this.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, null);
}
return;
}
this.ProcessDuplexMessage(info);
}
class DuplexServerReliableSession : ServerReliableSession, IDuplexSession
{
ServerReliableDuplexSessionChannel channel;
public DuplexServerReliableSession(ServerReliableDuplexSessionChannel channel,
ReliableChannelListenerBase<IDuplexSessionChannel> listener, FaultHelper faultHelper, UniqueId inputID,
UniqueId outputID)
: base(channel, listener, (IServerReliableChannelBinder)channel.Binder, faultHelper, inputID, outputID)
{
this.channel = channel;
}
public IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state)
{
return this.BeginCloseOutputSession(this.channel.DefaultCloseTimeout, callback, state);
}
public IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
{
return channel.OnBeginCloseOutputSession(timeout, callback, state);
}
public void EndCloseOutputSession(IAsyncResult result)
{
channel.OnEndCloseOutputSession(result);
}
public void CloseOutputSession()
{
this.CloseOutputSession(this.channel.DefaultCloseTimeout);
}
public void CloseOutputSession(TimeSpan timeout)
{
channel.OnCloseOutputSession(timeout);
}
}
}
}