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

477 lines
19 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Globalization;
using System.Collections.Generic;
using System.EnterpriseServices;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Threading;
using System.ServiceModel.Diagnostics;
using System.Transactions;
class MsmqSubqueueLockingQueue : MsmqQueue, ILockingQueue
{
string lockQueueName;
MsmqQueue mainQueueForMove;
MsmqQueue lockQueueForMove;
MsmqQueue lockQueueForReceive;
IOThreadTimer lockCollectionTimer;
TimeSpan lockCollectionInterval = TimeSpan.FromMinutes(5);
object timerLock = new object();
bool disposed;
string hostname;
bool validHostName;
private const string LockSubqueuePrefix = "lock_";
public MsmqSubqueueLockingQueue(string formatName, string hostname, int accessMode)
: base(formatName, accessMode)
{
// The hostname will be empty for MsmqIntegrationBinding
if (string.Compare(hostname, string.Empty, StringComparison.OrdinalIgnoreCase) == 0)
{
this.validHostName = MsmqSubqueueLockingQueue.TryGetHostName(formatName, out hostname);
}
else
{
this.validHostName = true;
}
this.disposed = false;
this.lockQueueName = this.formatName + ";" + MsmqSubqueueLockingQueue.GenerateLockQueueName();
this.lockQueueForReceive = new MsmqQueue(this.lockQueueName, UnsafeNativeMethods.MQ_RECEIVE_ACCESS, UnsafeNativeMethods.MQ_DENY_RECEIVE_SHARE);
this.lockQueueForMove = new MsmqQueue(this.lockQueueName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
this.mainQueueForMove = new MsmqQueue(this.formatName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
this.lockCollectionTimer = new IOThreadTimer(new Action<object>(OnCollectionTimer), null, false);
if (string.Compare(hostname, "localhost", StringComparison.OrdinalIgnoreCase) == 0)
{
this.hostname = null;
}
else
{
this.hostname = hostname;
}
}
private static string GenerateLockQueueName()
{
string lockGuid = Guid.NewGuid().ToString();
return MsmqSubqueueLockingQueue.LockSubqueuePrefix + lockGuid.Substring(lockGuid.Length - 8, 8);
}
public MsmqQueue LockQueueForReceive
{
get
{
return this.lockQueueForReceive;
}
}
internal override MsmqQueueHandle OpenQueue()
{
if (!this.validHostName)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqOpenError,
MsmqError.GetErrorString(UnsafeNativeMethods.MQ_ERROR_UNSUPPORTED_FORMATNAME_OPERATION)),
UnsafeNativeMethods.MQ_ERROR_UNSUPPORTED_FORMATNAME_OPERATION));
}
this.EnsureLockQueuesOpen();
this.mainQueueForMove.EnsureOpen();
// first time collection
this.OnCollectionTimer(null);
return base.OpenQueue();
}
internal void EnsureLockQueuesOpen()
{
int attempts = 0;
// handle lock queue name collisions, if we fail three times in a row it is probably not the name
// collision that is causing the open to fail
while (true)
{
try
{
this.lockQueueForReceive.EnsureOpen();
break;
}
catch (MsmqException ex)
{
if (attempts >= 3)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ex);
}
MsmqDiagnostics.ExpectedException(ex);
}
this.lockQueueForReceive.Dispose();
this.lockQueueForMove.Dispose();
this.lockQueueName = this.formatName + ";" + MsmqSubqueueLockingQueue.GenerateLockQueueName();
this.lockQueueForReceive = new MsmqQueue(this.lockQueueName, UnsafeNativeMethods.MQ_RECEIVE_ACCESS, UnsafeNativeMethods.MQ_DENY_RECEIVE_SHARE);
this.lockQueueForMove = new MsmqQueue(this.lockQueueName, UnsafeNativeMethods.MQ_MOVE_ACCESS);
attempts++;
}
this.lockQueueForMove.EnsureOpen();
}
public override ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode)
{
// we ignore transaction mode for receive context receives
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
bool receivedMessage = false;
long lookupId = 0;
// peek for new message, move it to the lock queue and then receive the full message
// if move fails because another thread moved it ahead of us then peek again
while (!receivedMessage)
{
ReceiveResult result;
MoveReceiveResult moveResult;
using (MsmqMessageLookupId emptyMessage = new MsmqMessageLookupId())
{
result = this.TryPeek(emptyMessage, timeoutHelper.RemainingTime());
if (result != ReceiveResult.MessageReceived)
{
return result;
}
lookupId = emptyMessage.lookupId.Value;
}
try
{
moveResult = this.TryMoveMessage(lookupId, this.lockQueueForMove, MsmqTransactionMode.None);
if (moveResult == MoveReceiveResult.Succeeded)
{
receivedMessage = true;
}
}
catch (MsmqException ex)
{
MsmqDiagnostics.ExpectedException(ex);
}
}
MoveReceiveResult lookupIdReceiveResult;
try
{
lookupIdReceiveResult = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, message, MsmqTransactionMode.None, UnsafeNativeMethods.MQ_LOOKUP_PEEK_CURRENT);
}
catch (MsmqException ex)
{
this.UnlockMessage(lookupId, TimeSpan.Zero);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ex);
}
if (lookupIdReceiveResult == MoveReceiveResult.Succeeded)
{
return ReceiveResult.MessageReceived;
}
else
{
this.UnlockMessage(lookupId, TimeSpan.Zero);
return ReceiveResult.OperationCancelled;
}
}
public void DeleteMessage(long lookupId, TimeSpan timeout)
{
// operations on the lock subqueue need to be protected from ---- with close
MoveReceiveResult receiveResult;
IPostRollbackErrorStrategy postRollBack = new SimplePostRollbackErrorStrategy(lookupId);
do
{
using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage())
{
receiveResult = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, emptyMessage, MsmqTransactionMode.CurrentOrNone);
}
if (receiveResult != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
break;
// We could have failed because of ---- with transaction.abort() for the transaction
// that had this message locked previously. We will retry in these cases.
} while (postRollBack.AnotherTryNeeded());
// We could have failed because of
// a) failure in the underlying queue manager
// b) expiration of the native message timer
// c) ---- with Channel.Close()
// ..not much we can do in any of these cases
if (receiveResult != MoveReceiveResult.Succeeded)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveContextMessageNotReceived, lookupId.ToString(CultureInfo.InvariantCulture))));
}
}
public void UnlockMessage(long lookupId, TimeSpan timeout)
{
MoveReceiveResult moveResult;
IPostRollbackErrorStrategy postRollBack = new SimplePostRollbackErrorStrategy(lookupId);
do
{
moveResult = this.lockQueueForReceive.TryMoveMessage(lookupId, this.mainQueueForMove, MsmqTransactionMode.None);
if (moveResult != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
break;
// We could have failed because of ---- with transaction.abort() for the transaction
// that had this message locked previously. We will retry in these cases.
} while (postRollBack.AnotherTryNeeded());
if (moveResult != MoveReceiveResult.Succeeded)
{
// We could have failed because of
// a) failure in the underlying queue manager
// b) expiration of the native message timer
// c) ---- with Channel.Close()
// ..not much we can do in any of these cases
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveContextMessageNotMoved, lookupId.ToString(CultureInfo.InvariantCulture))));
}
}
public override void CloseQueue()
{
lock (this.timerLock)
{
if (!this.disposed)
{
this.disposed = true;
this.lockCollectionTimer.Cancel();
this.lockCollectionTimer = null;
}
}
this.CollectLocks(this.lockQueueForReceive);
this.mainQueueForMove.CloseQueue();
this.lockQueueForMove.CloseQueue();
this.lockQueueForReceive.CloseQueue();
base.CloseQueue();
}
private void OnCollectionTimer(object state)
{
lock (this.timerLock)
{
if (this.disposed)
{
return;
}
List<string> subqueues;
if (TryEnumerateSubqueues(out subqueues))
{
foreach (string subqueueName in subqueues)
{
if (subqueueName.StartsWith(MsmqSubqueueLockingQueue.LockSubqueuePrefix, StringComparison.OrdinalIgnoreCase))
{
MsmqQueue collectQueue;
if (TryOpenLockQueueForCollection(subqueueName, out collectQueue))
{
this.CollectLocks(collectQueue);
}
}
}
}
this.lockCollectionTimer.Set(this.lockCollectionInterval);
}
}
private bool TryOpenLockQueueForCollection(string subqueueName, out MsmqQueue lockQueue)
{
lockQueue = null;
string formatName = this.formatName + ";" + subqueueName;
int accessMode = UnsafeNativeMethods.MQ_RECEIVE_ACCESS;
int shareMode = UnsafeNativeMethods.MQ_DENY_RECEIVE_SHARE;
try
{
int error = 0;
if (MsmqQueue.IsQueueOpenable(formatName, accessMode, shareMode, out error))
{
lockQueue = new MsmqQueue(formatName, accessMode, shareMode);
lockQueue.EnsureOpen();
}
else
{
// The lock subqueue is either being actively used by a channel or is not available.
// So, we do not have to collect this lock queue.
if (error == UnsafeNativeMethods.MQ_ERROR_SHARING_VIOLATION ||
error == UnsafeNativeMethods.MQ_ERROR_QUEUE_NOT_FOUND)
{
return false;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqOpenError, MsmqError.GetErrorString(error)), error));
}
}
}
catch (MsmqException)
{
// The error has already been logged. Since this function is to decide whether to collect
// the lock queue, we return false.
return false;
}
return true;
}
private void CollectLocks(MsmqQueue lockQueue)
{
ReceiveResult result = ReceiveResult.MessageReceived;
while (result == ReceiveResult.MessageReceived)
{
using (MsmqMessageLookupId message = new MsmqMessageLookupId())
{
try
{
result = lockQueue.TryPeek(message, TimeSpan.FromSeconds(0));
if (result == ReceiveResult.MessageReceived)
{
lockQueue.TryMoveMessage(message.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None);
}
}
catch (MsmqException ex)
{
// we will retry the collection in the next cleanup round
MsmqDiagnostics.ExpectedException(ex);
result = ReceiveResult.Unknown;
}
}
}
}
private bool TryEnumerateSubqueues(out List<String> subqueues)
{
subqueues = new List<string>();
int[] ids = new int[1];
UnsafeNativeMethods.MQMSGPROPS props = new UnsafeNativeMethods.MQMSGPROPS();
UnsafeNativeMethods.MQPROPVARIANT prop = new UnsafeNativeMethods.MQPROPVARIANT();
UnsafeNativeMethods.MQPROPVARIANT retProp;
GCHandle propsHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
GCHandle nativePropertyIdsHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
GCHandle propHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
props.status = IntPtr.Zero;
props.count = 1;
ids[0] = UnsafeNativeMethods.PROPID_MGMT_QUEUE_SUBQUEUE_NAMES;
prop.vt = UnsafeNativeMethods.VT_NULL;
try
{
// pin
propsHandle.Target = props;
nativePropertyIdsHandle.Target = ids;
propHandle.Target = prop;
props.variants = propHandle.AddrOfPinnedObject();
props.ids = nativePropertyIdsHandle.AddrOfPinnedObject();
if (UnsafeNativeMethods.MQMgmtGetInfo(this.hostname, "queue=" + this.formatName, propsHandle.AddrOfPinnedObject()) == 0)
{
retProp = (UnsafeNativeMethods.MQPROPVARIANT)Marshal.PtrToStructure(props.variants, typeof(UnsafeNativeMethods.MQPROPVARIANT));
IntPtr[] stringArrays = new IntPtr[retProp.stringArraysValue.count];
Marshal.Copy(retProp.stringArraysValue.stringArrays, stringArrays, 0, retProp.stringArraysValue.count);
for (int i = 0; i < retProp.stringArraysValue.count; i++)
{
subqueues.Add(Marshal.PtrToStringUni(stringArrays[i]));
UnsafeNativeMethods.MQFreeMemory(stringArrays[i]);
}
UnsafeNativeMethods.MQFreeMemory(retProp.stringArraysValue.stringArrays);
}
else
{
return false;
}
}
finally
{
// unpin
nativePropertyIdsHandle.Target = null;
propsHandle.Target = null;
propHandle.Target = null;
}
return true;
}
private class MsmqMessageLookupId : NativeMsmqMessage
{
public LongProperty lookupId;
public MsmqMessageLookupId()
: base(1)
{
this.lookupId = new LongProperty(this, UnsafeNativeMethods.PROPID_M_LOOKUPID);
}
}
private static bool TryGetHostName(string formatName, out string hostName)
{
string directFormatNamePrefix = "DIRECT=";
string tcpProtocolPrefix = "TCP:";
string osProtocolPrefix = "OS:";
hostName = null;
if (formatName.StartsWith(directFormatNamePrefix, StringComparison.OrdinalIgnoreCase))
{
// The direct format name of the form DIRECT=OS:.\sampleq is parsed here
string formatNameWithProtocol = formatName.Substring(directFormatNamePrefix.Length,
formatName.Length - directFormatNamePrefix.Length);
int addressStartPos = formatNameWithProtocol.IndexOf(':') + 1;
string address = formatNameWithProtocol.Substring(addressStartPos,
formatNameWithProtocol.IndexOf('\\') - addressStartPos);
if (formatNameWithProtocol.StartsWith(tcpProtocolPrefix, StringComparison.OrdinalIgnoreCase))
{
// formatNameWithProtocol is TCP:<tcp-address>\<queue-type>\<queue-name>
hostName = address;
return true;
}
else if (formatNameWithProtocol.StartsWith(osProtocolPrefix, StringComparison.OrdinalIgnoreCase))
{
if (address.Equals("."))
{
// formatNameWithProtocol is OS:.\<queue-type>\<queue-name>
hostName = "localhost";
}
else
{
// formatNameWithProtocol is OS:<machine-name>\<queue-type>\<queue-name>
hostName = address;
}
return true;
}
else
{
// Other protocols not supported. IPX is valid only on NT, w2k
// HTTP/HTTPS: can be used only to send messages. If support changes in future,
// use Dns.GetHostEntry to obtain the IP address
return false;
}
}
else
{
// Other format names are not supported
return false;
}
}
}
}