void OnInactivityElapsed(object state)
{
WsrmFault fault;
Exception e;
string exceptionMessage = SR.GetString(SR.SequenceTerminatedInactivityTimeoutExceeded, this.settings.InactivityTimeout);
if (TD.InactivityTimeoutIsEnabled())
{
TD.InactivityTimeout(exceptionMessage);
}
if (this.SequenceID != null)
{
string faultReason = SR.GetString(SR.SequenceTerminatedInactivityTimeoutExceeded, this.settings.InactivityTimeout);
fault = SequenceTerminatedFault.CreateCommunicationFault(this.SequenceID, faultReason, exceptionMessage);
e = fault.CreateException();
}
else
{
fault = null;
e = new CommunicationException(exceptionMessage);
}
OnLocalFault(e, fault, null);
}
bool InternalAddMessage(Message message, TimeSpan timeout, object state, bool isLast)
{
MessageAttemptInfo attemptInfo;
TimeoutHelper helper = new TimeoutHelper(timeout);
try
{
if (isLast)
{
if (state != null)
{
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
}
attemptInfo = this.strategy.AddLast(message, helper.RemainingTime(), null);
}
else if (!this.strategy.Add(message, helper.RemainingTime(), state, out attemptInfo))
{
return(false);
}
}
catch (TimeoutException)
{
if (isLast)
{
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
}
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
throw;
}
catch (Exception e)
{
if (!Fx.IsFatal(e))
{
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
}
throw;
}
if (sendGuard.Enter())
{
try
{
this.sendHandler(attemptInfo, helper.RemainingTime(), false);
}
catch (QuotaExceededException)
{
this.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.id));
throw;
}
finally
{
this.sendGuard.Exit();
}
}
return(true);
}
public virtual void Abort()
{
this.guard.Abort();
this.inactivityTimer.Abort();
// Try to send a fault.
bool sendFault;
lock (this.ThisLock)
{
// Faulted thread already cleaned up. No need to to anything more.
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
// Can only send a fault if the other side did not send one already.
sendFault = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted); // NotFaulted || LocallyFaulted
this.faulted = SessionFaultState.CleanedUp;
}
if (sendFault)
{
if ((this.binder.State == CommunicationState.Opened) &&
this.binder.Connected &&
(this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceId = this.InputID ?? this.OutputID;
if (sequenceId != null)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(sequenceId, SR.GetString(SR.SequenceTerminatedOnAbort), null);
this.terminatingFault = fault.CreateMessage(this.settings.MessageVersion,
this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
}
// Got here so the session did not actually send a fault, must clean up resources.
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public AddAsyncResult(Message message, bool isLast, TimeSpan timeout, object state,
ReliableOutputConnection connection, AsyncCallback callback, object asyncState)
: base(callback, asyncState)
{
this.connection = connection;
this.timeoutHelper = new TimeoutHelper(timeout);
this.isLast = isLast;
bool complete = false;
IAsyncResult result;
try
{
if (isLast)
{
if (state != null)
{
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
}
result = this.connection.strategy.BeginAddLast(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
}
else
{
result = this.connection.strategy.BeginAdd(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
}
}
catch (TimeoutException)
{
if (isLast)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
}
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
throw;
}
catch (Exception e)
{
if (!Fx.IsFatal(e))
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
}
throw;
}
if (result.CompletedSynchronously)
{
complete = this.CompleteAdd(result);
}
if (complete)
{
this.Complete(true);
}
}
private bool InternalAddMessage(Message message, TimeSpan timeout, object state, bool isLast)
{
MessageAttemptInfo info;
TimeoutHelper helper = new TimeoutHelper(timeout);
try
{
if (isLast)
{
if (state != null)
{
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
}
info = this.strategy.AddLast(message, helper.RemainingTime(), null);
}
else if (!this.strategy.Add(message, helper.RemainingTime(), state, out info))
{
return(false);
}
}
catch (TimeoutException)
{
if (isLast)
{
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, System.ServiceModel.SR.GetString("SequenceTerminatedAddLastToWindowTimedOut"), null));
}
throw;
}
catch (Exception exception)
{
if (!Fx.IsFatal(exception))
{
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, System.ServiceModel.SR.GetString("SequenceTerminatedUnknownAddToWindowError"), null));
}
throw;
}
if (this.sendGuard.Enter())
{
try
{
this.sendHandler(info, helper.RemainingTime(), false);
}
catch (QuotaExceededException)
{
this.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.id));
throw;
}
finally
{
this.sendGuard.Exit();
}
}
return(true);
}
public AddAsyncResult(Message message, bool isLast, TimeSpan timeout, object state, ReliableOutputConnection connection, AsyncCallback callback, object asyncState) : base(callback, asyncState)
{
IAsyncResult result;
this.connection = connection;
this.timeoutHelper = new TimeoutHelper(timeout);
this.isLast = isLast;
bool flag = false;
try
{
if (isLast)
{
if (state != null)
{
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
}
result = this.connection.strategy.BeginAddLast(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
}
else
{
result = this.connection.strategy.BeginAdd(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
}
}
catch (TimeoutException)
{
if (isLast)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, System.ServiceModel.SR.GetString("SequenceTerminatedAddLastToWindowTimedOut"), null));
}
throw;
}
catch (Exception exception)
{
if (!Fx.IsFatal(exception))
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, System.ServiceModel.SR.GetString("SequenceTerminatedUnknownAddToWindowError"), null));
}
throw;
}
if (result.CompletedSynchronously)
{
flag = this.CompleteAdd(result);
}
if (flag)
{
base.Complete(true);
}
}
private void OnInactivityElapsed(object state)
{
WsrmFault fault;
Exception exception;
string exceptionMessage = System.ServiceModel.SR.GetString("SequenceTerminatedInactivityTimeoutExceeded", new object[] { this.settings.InactivityTimeout });
if (this.SequenceID != null)
{
string faultReason = System.ServiceModel.SR.GetString("SequenceTerminatedInactivityTimeoutExceeded", new object[] { this.settings.InactivityTimeout });
fault = SequenceTerminatedFault.CreateCommunicationFault(this.SequenceID, faultReason, exceptionMessage);
exception = fault.CreateException();
}
else
{
fault = null;
exception = new CommunicationException(exceptionMessage);
}
this.OnLocalFault(exception, fault, null);
}
public virtual void Abort()
{
bool flag;
this.guard.Abort();
this.inactivityTimer.Abort();
lock (this.ThisLock)
{
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
flag = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted);
this.faulted = SessionFaultState.CleanedUp;
}
if (((flag && (this.binder.State == CommunicationState.Opened)) && this.binder.Connected) && (this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceID = this.InputID ?? this.OutputID;
if (sequenceID != null)
{
this.terminatingFault = SequenceTerminatedFault.CreateCommunicationFault(sequenceID, System.ServiceModel.SR.GetString("SequenceTerminatedOnAbort"), null).CreateMessage(this.settings.MessageVersion, this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public Message WaitForReply(TimeSpan timeout)
{
bool throwing = true;
try
{
bool expired = false;
if (!this.completed)
{
bool wait = false;
lock (this.ThisLock)
{
if (!this.completed)
{
wait = true;
this.completedHandle = new ManualResetEvent(false);
}
}
if (wait)
{
expired = !TimeoutHelper.WaitOne(this.completedHandle, timeout);
lock (this.ThisLock)
{
if (!this.completed)
{
this.completed = true;
}
else
{
expired = false;
}
}
this.completedHandle.Close();
}
}
if (this.aborted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.CreateClosedException());
}
else if (this.faulted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.GetTerminalException());
}
else if (expired)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.TimeoutOnRequest, this.originalTimeout)));
}
else
{
throwing = false;
return(this.reply);
}
}
finally
{
if (throwing)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(this.parent.session.InputID,
SR.GetString(SR.SequenceTerminatedReliableRequestThrew), null);
this.parent.session.OnLocalFault(null, fault, null);
if (this.completedHandle != null)
{
this.completedHandle.Close();
}
}
}
}
public Message WaitForReply(TimeSpan timeout)
{
Message reply;
bool flag = true;
try
{
bool flag2 = false;
if (!this.completed)
{
bool flag3 = false;
lock (this.ThisLock)
{
if (!this.completed)
{
flag3 = true;
this.completedHandle = new ManualResetEvent(false);
}
}
if (flag3)
{
flag2 = !TimeoutHelper.WaitOne(this.completedHandle, timeout);
lock (this.ThisLock)
{
if (!this.completed)
{
this.completed = true;
}
else
{
flag2 = false;
}
}
this.completedHandle.Close();
}
}
if (this.aborted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.CreateClosedException());
}
if (this.faulted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.GetTerminalException());
}
if (flag2)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(System.ServiceModel.SR.GetString("TimeoutOnRequest", new object[] { this.originalTimeout })));
}
flag = false;
reply = this.reply;
}
finally
{
if (flag)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(this.parent.session.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedReliableRequestThrew"), null);
this.parent.session.OnLocalFault(null, fault, null);
if (this.completedHandle != null)
{
this.completedHandle.Close();
}
}
}
return(reply);
}
private bool CompleteAdd(IAsyncResult result)
{
MessageAttemptInfo attemptInfo = new MessageAttemptInfo();
this.validAdd = true;
try
{
if (this.isLast)
{
attemptInfo = this.connection.strategy.EndAddLast(result);
}
else if (!this.connection.strategy.EndAdd(result, out attemptInfo))
{
this.validAdd = false;
return(true);
}
}
catch (TimeoutException)
{
if (this.isLast)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, System.ServiceModel.SR.GetString("SequenceTerminatedAddLastToWindowTimedOut"), null));
}
throw;
}
catch (Exception exception)
{
if (!Fx.IsFatal(exception))
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, System.ServiceModel.SR.GetString("SequenceTerminatedUnknownAddToWindowError"), null));
}
throw;
}
if (this.connection.sendGuard.Enter())
{
bool flag = true;
try
{
result = this.connection.beginSendHandler(attemptInfo, this.timeoutHelper.RemainingTime(), false, sendCompleteStatic, this);
flag = false;
}
catch (QuotaExceededException)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.connection.id));
throw;
}
finally
{
if (flag)
{
this.connection.sendGuard.Exit();
}
}
}
else
{
return(true);
}
if (result.CompletedSynchronously)
{
this.CompleteSend(result);
return(true);
}
return(false);
}
bool CompleteAdd(IAsyncResult result)
{
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
this.validAdd = true;
try
{
if (this.isLast)
{
attemptInfo = this.connection.strategy.EndAddLast(result);
}
else if (!this.connection.strategy.EndAdd(result, out attemptInfo))
{
this.validAdd = false;
return(true);
}
}
catch (TimeoutException)
{
if (this.isLast)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
}
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
throw;
}
catch (Exception e)
{
if (!Fx.IsFatal(e))
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
}
throw;
}
if (this.connection.sendGuard.Enter())
{
bool throwing = true;
try
{
result = this.connection.beginSendHandler(attemptInfo, this.timeoutHelper.RemainingTime(), false, sendCompleteStatic, this);
throwing = false;
}
catch (QuotaExceededException)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.connection.id));
throw;
}
finally
{
if (throwing)
{
this.connection.sendGuard.Exit();
}
}
}
else
{
return(true);
}
if (result.CompletedSynchronously)
{
this.CompleteSend(result);
return(true);
}
else
{
return(false);
}
}
public async Task <Message> ReceiveReplyAsync(TimeoutHelper timeoutHelper)
{
bool throwing = true;
try
{
bool expired = false;
if (!_completed)
{
bool wait = false;
lock (ThisLock)
{
if (!_completed)
{
wait = true;
_tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
}
}
if (wait)
{
expired = !await TaskHelpers.AwaitWithTimeout(_tcs.Task, timeoutHelper.RemainingTime());
lock (ThisLock)
{
if (!_completed)
{
_completed = true;
}
else
{
expired = false;
}
}
}
}
if (_aborted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(_parent.CreateClosedException());
}
else if (_faulted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(_parent.GetTerminalException());
}
else if (expired)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.Format(SR.TimeoutOnRequest, _originalTimeout)));
}
else
{
throwing = false;
return(_reply);
}
}
finally
{
if (throwing)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(_parent.session.InputID,
SR.SequenceTerminatedReliableRequestThrew, null);
_parent.session.OnLocalFault(null, fault, null);
}
}
}
