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

349 lines
14 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Runtime;
using System.Threading;
using System.ServiceModel.Diagnostics.Application;
sealed class Msmq4PoisonHandler : IPoisonHandlingStrategy
{
MsmqQueue mainQueue;
MsmqQueue mainQueueForMove;
MsmqQueue retryQueueForPeek;
MsmqQueue retryQueueForMove;
MsmqQueue poisonQueue;
MsmqQueue lockQueueForReceive;
IOThreadTimer timer;
MsmqReceiveHelper receiver;
bool disposed;
string poisonQueueName;
string retryQueueName;
string mainQueueName;
MsmqRetryQueueMessage retryQueueMessage;
static Action<object> onStartPeek = new Action<object>(StartPeek);
static AsyncCallback onPeekCompleted = Fx.ThunkCallback(OnPeekCompleted);
public Msmq4PoisonHandler(MsmqReceiveHelper receiver)
{
this.receiver = receiver;
this.timer = new IOThreadTimer(new Action<object>(OnTimer), null, false);
this.disposed = false;
this.mainQueueName = this.ReceiveParameters.AddressTranslator.UriToFormatName(this.ListenUri);
this.poisonQueueName = this.ReceiveParameters.AddressTranslator.UriToFormatName(new Uri(this.ListenUri.AbsoluteUri + ";poison"));
this.retryQueueName = this.ReceiveParameters.AddressTranslator.UriToFormatName(new Uri(this.ListenUri.AbsoluteUri + ";retry"));
}
MsmqReceiveParameters ReceiveParameters
{
get { return this.receiver.MsmqReceiveParameters; }
}
Uri ListenUri
{
get { return this.receiver.ListenUri; }
}
public void Open()
{
if (this.ReceiveParameters.ReceiveContextSettings.Enabled)
{
Fx.Assert(this.receiver.Queue is MsmqSubqueueLockingQueue, "Queue must be MsmqSubqueueLockingQueue");
this.lockQueueForReceive = ((MsmqSubqueueLockingQueue)this.receiver.Queue).LockQueueForReceive;
}
this.mainQueue = this.receiver.Queue;
this.mainQueueForMove = new MsmqQueue(this.mainQueueName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
// Open up the poison queue (for handling poison messages).
this.poisonQueue = new MsmqQueue(this.poisonQueueName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
this.retryQueueForMove = new MsmqQueue(this.retryQueueName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
this.retryQueueForPeek = new MsmqQueue(this.retryQueueName, UnsafeNativeMethods.MQ_RECEIVE_ACCESS);
this.retryQueueMessage = new MsmqRetryQueueMessage();
if (Thread.CurrentThread.IsThreadPoolThread)
{
StartPeek(this);
}
else
{
ActionItem.Schedule(Msmq4PoisonHandler.onStartPeek, this);
}
}
static void StartPeek(object state)
{
Msmq4PoisonHandler handler = state as Msmq4PoisonHandler;
lock (handler)
{
if (!handler.disposed)
{
handler.retryQueueForPeek.BeginPeek(handler.retryQueueMessage, TimeSpan.MaxValue, onPeekCompleted, handler);
}
}
}
public bool CheckAndHandlePoisonMessage(MsmqMessageProperty messageProperty)
{
if (this.ReceiveParameters.ReceiveContextSettings.Enabled)
{
return ReceiveContextPoisonHandling(messageProperty);
}
else
{
return NonReceiveContextPoisonHandling(messageProperty);
}
}
public bool ReceiveContextPoisonHandling(MsmqMessageProperty messageProperty)
{
// The basic idea is to use the message move count to get the number of retry attempts the message has been through
// The computation of the retry count and retry cycle count is slightly involved due to fact that the message being processed
// could have been recycled message. (Recycled message is the message that moves from lock queue to retry queue to main queue
// and back to lock queue
//
// Count to tally message recycling (lock queue to retry queue to main queue adds move count of 2 to the message)
const int retryMoveCount = 2;
// Actual number of times message is received before recycling to retry queue
int actualReceiveRetryCount = this.ReceiveParameters.ReceiveRetryCount + 1;
// The message is recycled these many number of times
int maxRetryCycles = this.ReceiveParameters.MaxRetryCycles;
// Max change in message move count between recycling
int maxMovePerCycle = (2 * actualReceiveRetryCount) + 1;
// Number of recycles the message has been through
int messageCyclesCompleted = messageProperty.MoveCount / (maxMovePerCycle + retryMoveCount);
// Total number of moves on the message at the end of the last recycle
int messageMoveCountForCyclesCompleted = messageCyclesCompleted * (maxMovePerCycle + retryMoveCount);
// The differential move count for the current cycle
int messageMoveCountForCurrentCycle = messageProperty.MoveCount - messageMoveCountForCyclesCompleted;
lock (this)
{
if (this.disposed)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
// Check if the message has already completed its max recycle count (MaxRetryCycles)
// and the disposed the message first. Such a message was previously disposed using the ReceiveErrorHandling method
// and the channel/listener would immediately fault
//
if (messageCyclesCompleted > maxRetryCycles)
{
FinalDisposition(messageProperty);
return true;
}
// Check if the message is eligible for recycling/disposition
if (messageMoveCountForCurrentCycle >= maxMovePerCycle)
{
if (TD.ReceiveRetryCountReachedIsEnabled())
{
TD.ReceiveRetryCountReached(messageProperty.MessageId);
}
if (messageCyclesCompleted < maxRetryCycles)
{
// The message is eligible for recycling, move the message the message to retry queue
MsmqReceiveHelper.MoveReceivedMessage(this.lockQueueForReceive, this.retryQueueForMove, messageProperty.LookupId);
MsmqDiagnostics.PoisonMessageMoved(messageProperty.MessageId, false, this.receiver.InstanceId);
}
else
{
if (TD.MaxRetryCyclesExceededMsmqIsEnabled())
{
TD.MaxRetryCyclesExceededMsmq(messageProperty.MessageId);
}
// Dispose the message using ReceiveErrorHandling
FinalDisposition(messageProperty);
}
return true;
}
else
{
return false;
}
}
}
public bool NonReceiveContextPoisonHandling(MsmqMessageProperty messageProperty)
{
if (messageProperty.AbortCount <= this.ReceiveParameters.ReceiveRetryCount)
return false;
int retryCycle = messageProperty.MoveCount / 2;
lock (this)
{
if (this.disposed)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
if (retryCycle >= this.ReceiveParameters.MaxRetryCycles)
{
if (TD.MaxRetryCyclesExceededMsmqIsEnabled())
{
TD.MaxRetryCyclesExceededMsmq(messageProperty.MessageId);
}
FinalDisposition(messageProperty);
}
else
{
MsmqReceiveHelper.MoveReceivedMessage(this.mainQueue, this.retryQueueForMove, messageProperty.LookupId);
MsmqDiagnostics.PoisonMessageMoved(messageProperty.MessageId, false, this.receiver.InstanceId);
}
}
return true;
}
public void FinalDisposition(MsmqMessageProperty messageProperty)
{
if (this.ReceiveParameters.ReceiveContextSettings.Enabled)
{
this.InternalFinalDisposition(this.lockQueueForReceive, messageProperty);
}
else
{
this.InternalFinalDisposition(this.mainQueue, messageProperty);
}
}
private void InternalFinalDisposition(MsmqQueue disposeFromQueue, MsmqMessageProperty messageProperty)
{
switch (this.ReceiveParameters.ReceiveErrorHandling)
{
case ReceiveErrorHandling.Drop:
this.receiver.DropOrRejectReceivedMessage(disposeFromQueue, messageProperty, false);
break;
case ReceiveErrorHandling.Fault:
MsmqReceiveHelper.TryAbortTransactionCurrent();
if (null != this.receiver.ChannelListener)
this.receiver.ChannelListener.FaultListener();
if (null != this.receiver.Channel)
this.receiver.Channel.FaultChannel();
break;
case ReceiveErrorHandling.Reject:
this.receiver.DropOrRejectReceivedMessage(disposeFromQueue, messageProperty, true);
MsmqDiagnostics.PoisonMessageRejected(messageProperty.MessageId, this.receiver.InstanceId);
break;
case ReceiveErrorHandling.Move:
MsmqReceiveHelper.MoveReceivedMessage(disposeFromQueue, this.poisonQueue, messageProperty.LookupId);
MsmqDiagnostics.PoisonMessageMoved(messageProperty.MessageId, true, this.receiver.InstanceId);
break;
default:
Fx.Assert("System.ServiceModel.Channels.Msmq4PoisonHandler.FinalDisposition(): (unexpected ReceiveErrorHandling)");
break;
}
}
public void Dispose()
{
lock (this)
{
if (!this.disposed)
{
this.disposed = true;
this.timer.Cancel();
if (null != this.retryQueueForPeek)
this.retryQueueForPeek.Dispose();
if (null != this.retryQueueForMove)
this.retryQueueForMove.Dispose();
if (null != this.poisonQueue)
this.poisonQueue.Dispose();
if (null != this.mainQueueForMove)
this.mainQueueForMove.Dispose();
}
}
}
static void OnPeekCompleted(IAsyncResult result)
{
Msmq4PoisonHandler handler = result.AsyncState as Msmq4PoisonHandler;
MsmqQueue.ReceiveResult receiveResult = MsmqQueue.ReceiveResult.Unknown;
try
{
receiveResult = handler.retryQueueForPeek.EndPeek(result);
}
catch (MsmqException ex)
{
MsmqDiagnostics.ExpectedException(ex);
}
if (MsmqQueue.ReceiveResult.MessageReceived == receiveResult)
{
lock (handler)
{
if (!handler.disposed)
{
// Check the time - move it, and begin peeking again
// if necessary, or wait for the timeout.
DateTime lastMoveTime = MsmqDateTime.ToDateTime(handler.retryQueueMessage.LastMoveTime.Value);
TimeSpan waitTime = lastMoveTime + handler.ReceiveParameters.RetryCycleDelay - DateTime.UtcNow;
if (waitTime < TimeSpan.Zero)
handler.OnTimer(handler);
else
handler.timer.Set(waitTime);
}
}
}
}
void OnTimer(object state)
{
lock (this)
{
if (!this.disposed)
{
try
{
this.retryQueueForPeek.TryMoveMessage(this.retryQueueMessage.LookupId.Value, this.mainQueueForMove, MsmqTransactionMode.Single);
}
catch (MsmqException ex)
{
MsmqDiagnostics.ExpectedException(ex);
}
this.retryQueueForPeek.BeginPeek(this.retryQueueMessage, TimeSpan.MaxValue, onPeekCompleted, this);
}
}
}
class MsmqRetryQueueMessage : NativeMsmqMessage
{
LongProperty lookupId;
IntProperty lastMoveTime;
public MsmqRetryQueueMessage()
: base(2)
{
this.lookupId = new LongProperty(this, UnsafeNativeMethods.PROPID_M_LOOKUPID);
this.lastMoveTime = new IntProperty(this, UnsafeNativeMethods.PROPID_M_LAST_MOVE_TIME);
}
public LongProperty LookupId
{
get { return this.lookupId; }
}
public IntProperty LastMoveTime
{
get { return this.lastMoveTime; }
}
}
}
}