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

835 lines
27 KiB
C#

//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Runtime;
using System.Threading;
using System.Xml;
delegate IAsyncResult BeginSendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException, AsyncCallback asyncCallback, object state);
delegate void EndSendHandler(IAsyncResult result);
delegate void SendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException);
delegate void ComponentFaultedHandler(Exception faultException, WsrmFault fault);
delegate void ComponentExceptionHandler(Exception exception);
delegate void RetryHandler(MessageAttemptInfo attemptInfo);
sealed class ReliableOutputConnection
{
BeginSendHandler beginSendHandler;
OperationWithTimeoutBeginCallback beginSendAckRequestedHandler;
bool closed = false;
EndSendHandler endSendHandler;
OperationEndCallback endSendAckRequestedHandler;
UniqueId id;
MessageVersion messageVersion;
object mutex = new Object();
static AsyncCallback onSendRetriesComplete = Fx.ThunkCallback(new AsyncCallback(OnSendRetriesComplete));
static AsyncCallback onSendRetryComplete = Fx.ThunkCallback(new AsyncCallback(OnSendRetryComplete));
ReliableMessagingVersion reliableMessagingVersion;
Guard sendGuard = new Guard(Int32.MaxValue);
SendHandler sendHandler;
OperationWithTimeoutCallback sendAckRequestedHandler;
static Action<object> sendRetries = new Action<object>(SendRetries);
TimeSpan sendTimeout;
InterruptibleWaitObject shutdownHandle = new InterruptibleWaitObject(false);
TransmissionStrategy strategy;
bool terminated = false;
public ReliableOutputConnection(UniqueId id,
int maxTransferWindowSize,
MessageVersion messageVersion,
ReliableMessagingVersion reliableMessagingVersion,
TimeSpan initialRtt,
bool requestAcks,
TimeSpan sendTimeout)
{
this.id = id;
this.messageVersion = messageVersion;
this.reliableMessagingVersion = reliableMessagingVersion;
this.sendTimeout = sendTimeout;
this.strategy = new TransmissionStrategy(reliableMessagingVersion, initialRtt, maxTransferWindowSize,
requestAcks, id);
this.strategy.RetryTimeoutElapsed = OnRetryTimeoutElapsed;
this.strategy.OnException = RaiseOnException;
}
public ComponentFaultedHandler Faulted;
public ComponentExceptionHandler OnException;
MessageVersion MessageVersion
{
get
{
return this.messageVersion;
}
}
public BeginSendHandler BeginSendHandler
{
set
{
this.beginSendHandler = value;
}
}
public OperationWithTimeoutBeginCallback BeginSendAckRequestedHandler
{
set
{
this.beginSendAckRequestedHandler = value;
}
}
public bool Closed
{
get
{
return this.closed;
}
}
public EndSendHandler EndSendHandler
{
set
{
this.endSendHandler = value;
}
}
public OperationEndCallback EndSendAckRequestedHandler
{
set
{
this.endSendAckRequestedHandler = value;
}
}
public Int64 Last
{
get
{
return this.strategy.Last;
}
}
public SendHandler SendHandler
{
set
{
this.sendHandler = value;
}
}
public OperationWithTimeoutCallback SendAckRequestedHandler
{
set
{
this.sendAckRequestedHandler = value;
}
}
public TransmissionStrategy Strategy
{
get
{
return this.strategy;
}
}
object ThisLock
{
get { return this.mutex; }
}
public void Abort(ChannelBase channel)
{
this.sendGuard.Abort();
this.shutdownHandle.Abort(channel);
this.strategy.Abort(channel);
}
void CompleteTransfer(TimeSpan timeout)
{
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
Message message = Message.CreateMessage(this.MessageVersion, WsrmFeb2005Strings.LastMessageAction);
message.Properties.AllowOutputBatching = false;
// Return value ignored.
this.InternalAddMessage(message, timeout, null, true);
}
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.strategy.SetLast())
{
this.shutdownHandle.Set();
}
else
{
this.sendAckRequestedHandler(timeout);
}
}
else
{
throw Fx.AssertAndThrow("Unsupported version.");
}
}
public bool AddMessage(Message message, TimeSpan timeout, object state)
{
return this.InternalAddMessage(message, timeout, state, false);
}
public IAsyncResult BeginAddMessage(Message message, TimeSpan timeout, object state, AsyncCallback callback, object asyncState)
{
return new AddAsyncResult(message, false, timeout, state, this, callback, asyncState);
}
public bool EndAddMessage(IAsyncResult result)
{
return AddAsyncResult.End(result);
}
IAsyncResult BeginCompleteTransfer(TimeSpan timeout, AsyncCallback callback, object state)
{
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
Message message = Message.CreateMessage(this.MessageVersion, WsrmFeb2005Strings.LastMessageAction);
message.Properties.AllowOutputBatching = false;
return new AddAsyncResult(message, true, timeout, null, this, callback, state);
}
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.strategy.SetLast())
{
this.shutdownHandle.Set();
return new AlreadyCompletedTransferAsyncResult(callback, state);
}
else
{
return this.beginSendAckRequestedHandler(timeout, callback, state);
}
}
else
{
throw Fx.AssertAndThrow("Unsupported version.");
}
}
void EndCompleteTransfer(IAsyncResult result)
{
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
AddAsyncResult.End(result);
}
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
AlreadyCompletedTransferAsyncResult completedResult = result as AlreadyCompletedTransferAsyncResult;
if (completedResult != null)
{
completedResult.End();
}
else
{
this.endSendAckRequestedHandler(result);
}
}
else
{
throw Fx.AssertAndThrow("Unsupported version.");
}
}
public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
bool completeTransfer = false;
lock (this.ThisLock)
{
completeTransfer = !this.closed;
this.closed = true;
}
OperationWithTimeoutBeginCallback[] beginCallbacks;
OperationEndCallback[] endCallbacks;
beginCallbacks = new OperationWithTimeoutBeginCallback[] {
completeTransfer ? this.BeginCompleteTransfer : default(OperationWithTimeoutBeginCallback),
this.shutdownHandle.BeginWait,
this.sendGuard.BeginClose,
this.beginSendAckRequestedHandler };
endCallbacks = new OperationEndCallback[] {
completeTransfer ? this.EndCompleteTransfer : default(OperationEndCallback),
this.shutdownHandle.EndWait,
this.sendGuard.EndClose,
this.endSendAckRequestedHandler };
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout, beginCallbacks, endCallbacks, callback, state);
}
public bool CheckForTermination()
{
return this.strategy.DoneTransmitting;
}
public void Close(TimeSpan timeout)
{
bool completeTransfer = false;
lock (this.ThisLock)
{
completeTransfer = !this.closed;
this.closed = true;
}
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (completeTransfer)
{
this.CompleteTransfer(timeoutHelper.RemainingTime());
}
this.shutdownHandle.Wait(timeoutHelper.RemainingTime());
this.sendGuard.Close(timeoutHelper.RemainingTime());
this.strategy.Close();
}
void CompleteSendRetries(IAsyncResult result)
{
while (true)
{
this.endSendHandler(result);
this.sendGuard.Exit();
this.strategy.DequeuePending();
if (this.sendGuard.Enter())
{
MessageAttemptInfo attemptInfo = this.strategy.GetMessageInfoForRetry(true);
if (attemptInfo.Message == null)
{
break;
}
else
{
result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetriesComplete, this);
if (!result.CompletedSynchronously)
{
return;
}
}
}
else
{
return;
}
}
// We are here if there are no more messages to retry.
this.sendGuard.Exit();
this.OnTransferComplete();
}
void CompleteSendRetry(IAsyncResult result)
{
try
{
this.endSendHandler(result);
}
finally
{
this.sendGuard.Exit();
}
}
public void EndClose(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
this.strategy.Close();
}
public void Fault(ChannelBase channel)
{
this.sendGuard.Abort();
this.shutdownHandle.Fault(channel);
this.strategy.Fault(channel);
}
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 bool IsFinalAckConsistent(SequenceRangeCollection ranges)
{
return this.strategy.IsFinalAckConsistent(ranges);
}
void OnRetryTimeoutElapsed(MessageAttemptInfo attemptInfo)
{
if (this.sendGuard.Enter())
{
IAsyncResult result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetryComplete, this);
if (result.CompletedSynchronously)
{
this.CompleteSendRetry(result);
}
}
}
static void OnSendRetryComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
ReliableOutputConnection outputConnection = (ReliableOutputConnection)result.AsyncState;
try
{
outputConnection.CompleteSendRetry(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
outputConnection.RaiseOnException(e);
}
}
}
static void OnSendRetriesComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
ReliableOutputConnection outputConnection = (ReliableOutputConnection)result.AsyncState;
try
{
outputConnection.CompleteSendRetries(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
outputConnection.RaiseOnException(e);
}
}
}
void OnTransferComplete()
{
this.strategy.DequeuePending();
if (this.strategy.DoneTransmitting)
Terminate();
}
public void ProcessTransferred(Int64 transferred, SequenceRangeCollection ranges, int quotaRemaining)
{
if (transferred < 0)
{
throw Fx.AssertAndThrow("Argument transferred must be a valid sequence number or 0 for protocol messages.");
}
bool invalidAck;
// ignored, TransmissionStrategy is being used to keep track of what must be re-sent.
// In the Request-Reply case this state may not align with acks.
bool inconsistentAck;
this.strategy.ProcessAcknowledgement(ranges, out invalidAck, out inconsistentAck);
invalidAck = (invalidAck || ((transferred != 0) && !ranges.Contains(transferred)));
if (!invalidAck)
{
if ((transferred > 0) && this.strategy.ProcessTransferred(transferred, quotaRemaining))
{
ActionItem.Schedule(sendRetries, this);
}
else
{
this.OnTransferComplete();
}
}
else
{
WsrmFault fault = new InvalidAcknowledgementFault(this.id, ranges);
RaiseFault(fault.CreateException(), fault);
}
}
public void ProcessTransferred(SequenceRangeCollection ranges, int quotaRemaining)
{
bool invalidAck;
bool inconsistentAck;
this.strategy.ProcessAcknowledgement(ranges, out invalidAck, out inconsistentAck);
if (!invalidAck && !inconsistentAck)
{
if (this.strategy.ProcessTransferred(ranges, quotaRemaining))
{
ActionItem.Schedule(sendRetries, this);
}
else
{
this.OnTransferComplete();
}
}
else
{
WsrmFault fault = new InvalidAcknowledgementFault(this.id, ranges);
RaiseFault(fault.CreateException(), fault);
}
}
void RaiseFault(Exception faultException, WsrmFault fault)
{
ComponentFaultedHandler handler = this.Faulted;
if (handler != null)
handler(faultException, fault);
}
void RaiseOnException(Exception exception)
{
ComponentExceptionHandler handler = this.OnException;
if (handler != null)
handler(exception);
}
void SendRetries()
{
IAsyncResult result = null;
if (this.sendGuard.Enter())
{
MessageAttemptInfo attemptInfo = this.strategy.GetMessageInfoForRetry(false);
if (attemptInfo.Message != null)
{
result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetriesComplete, this);
}
if (result != null)
{
if (result.CompletedSynchronously)
{
this.CompleteSendRetries(result);
}
}
else
{
this.sendGuard.Exit();
this.OnTransferComplete();
}
}
}
static void SendRetries(object state)
{
ReliableOutputConnection outputConnection = (ReliableOutputConnection)state;
try
{
outputConnection.SendRetries();
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
outputConnection.RaiseOnException(e);
}
}
public void Terminate()
{
lock (this.ThisLock)
{
if (this.terminated)
return;
this.terminated = true;
}
this.shutdownHandle.Set();
}
sealed class AddAsyncResult : AsyncResult
{
static AsyncCallback addCompleteStatic = Fx.ThunkCallback(new AsyncCallback(AddComplete));
ReliableOutputConnection connection;
bool isLast;
static AsyncCallback sendCompleteStatic = Fx.ThunkCallback(new AsyncCallback(SendComplete));
TimeoutHelper timeoutHelper;
bool validAdd;
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);
}
static void AddComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
AddAsyncResult addResult = (AddAsyncResult)result.AsyncState;
bool complete = false;
Exception completeException = null;
try
{
complete = addResult.CompleteAdd(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
completeException = e;
}
if (complete || completeException != null)
addResult.Complete(false, completeException);
}
}
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;
}
}
void CompleteSend(IAsyncResult result)
{
try
{
this.connection.endSendHandler(result);
}
catch (QuotaExceededException)
{
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.connection.id));
throw;
}
finally
{
this.connection.sendGuard.Exit();
}
}
static void SendComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
AddAsyncResult addResult = (AddAsyncResult)result.AsyncState;
Exception completeException = null;
try
{
addResult.CompleteSend(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
completeException = e;
}
addResult.Complete(false, completeException);
}
}
public static bool End(IAsyncResult result)
{
AsyncResult.End<AddAsyncResult>(result);
return ((AddAsyncResult)result).validAdd;
}
}
class AlreadyCompletedTransferAsyncResult : CompletedAsyncResult
{
public AlreadyCompletedTransferAsyncResult(AsyncCallback callback, object state)
: base(callback, state)
{
}
public void End()
{
AsyncResult.End<AlreadyCompletedTransferAsyncResult>(this);
}
}
}
}