public MessageQueueConnection(IMsmqEndpointAddress address, QueueAccessMode accessMode)
{
_address = address;
_accessMode = accessMode;
_multicastAddress = null;
switch (_accessMode)
{
case QueueAccessMode.Send:
_formatName = _address.OutboundFormatName;
break;
case QueueAccessMode.Peek:
case QueueAccessMode.PeekAndAdmin:
case QueueAccessMode.Receive:
case QueueAccessMode.ReceiveAndAdmin:
_formatName = _address.InboundFormatName;
_multicastAddress = address.MulticastAddress;
break;
default:
throw new EndpointException(_address.Uri, "An endpoint connection cannot be send and receive");
}
_needReconnect = true;
}
public static bool ValidateQueueAccessMode(QueueAccessMode value)
{
if ((((value != QueueAccessMode.Send) && (value != QueueAccessMode.Peek)) && ((value != QueueAccessMode.Receive) && (value != QueueAccessMode.PeekAndAdmin))) && (value != QueueAccessMode.ReceiveAndAdmin))
{
return (value == QueueAccessMode.SendAndReceive);
}
return true;
}
public MsmqBusOptions(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode queueAccessMode, bool useInternalTransaction)
{
this.SharedModeDenyReceive = sharedModeDenyReceive;
this.EnableCache = enableCache;
this.QueueAccessMode = queueAccessMode;
this.Path = path;
this.UseInternalTransaction = useInternalTransaction;
}
public static MessageQueue Create(string serverName, string queueName, QueueAccessMode accessMode) {
if( !queueName.StartsWith("private$\\") )
queueName = "private$\\" + queueName;
queueName = string.Format("FormatName:DIRECT=OS:{0}\\{1}", !Tools.IsLocalHost(serverName) ? serverName : ".", queueName);
return new MessageQueue(queueName, false, true, accessMode);
}
/// <summary>
/// Initializes a new instance of <c>MSMQBusOptions</c> class.
/// </summary>
/// <param name="path">The location of the queue referenced by this System.Messaging.MessageQueue,
/// which can be "." for the local computer.</param>
/// <param name="sharedModeDenyReceive">The <see cref="System.Boolean"/> value which indicates whether
/// the exclusive read access should be granted to the first application
/// that accesses the queue.</param>
/// <param name="enableCache">The <see cref="System.Boolean"/> value which indicates whether
/// a connection cache should be created and used.</param>
/// <param name="queueAccessMode">The value that indicates the access mode for the queue.</param>
/// <param name="useInternalTransaction">The <see cref="System.Boolean"/> value which indicates whether the internal
/// transaction should be used when sending or receiving messages.</param>
/// <param name="messageFormatter">The formatter used to serialize an object into or deserialize
/// an object from the body of a message read from or written to the queue.</param>
public MSMQBusOptions(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode queueAccessMode, bool useInternalTransaction, IMessageFormatter messageFormatter)
{
this.SharedModeDenyReceive = sharedModeDenyReceive;
this.EnableCache = enableCache;
this.QueueAccessMode = queueAccessMode;
this.Path = path;
this.UseInternalTransaction = useInternalTransaction;
this.MessageFormatter = messageFormatter;
}
public static bool ValidateQueueAccessMode(QueueAccessMode value)
{
//
// note that QueueAccessMode has disjoined values
//
return (value == QueueAccessMode.Send) ||
(value == QueueAccessMode.Peek) ||
(value == QueueAccessMode.Receive) ||
(value == QueueAccessMode.PeekAndAdmin) ||
(value == QueueAccessMode.ReceiveAndAdmin) ||
(value == QueueAccessMode.SendAndReceive);
}
public MessageQueue CreateQueue(string queueName, QueueAccessMode accessMode, IMessageFormatter formatter)
{
var queue = new MessageQueue(queueName, accessMode)
{
Formatter = formatter ?? new JsonMessageFormatter(),
MessageReadPropertyFilter = new MessagePropertyFilter
{
ArrivedTime = true,
Body = true
}
};
return (queue);
}
public static QueueAccessModeHolder GetQueueAccessModeHolder(QueueAccessMode accessMode)
{
if (holders.ContainsKey(accessMode))
{
return holders[accessMode];
}
lock (holders)
{
QueueAccessModeHolder holder = new QueueAccessModeHolder(accessMode);
holders[accessMode] = holder;
return holder;
}
}
public OpenedQueue Open(QueueAccessMode access, IMessageFormatter formatter)
{
var messageQueue = new MessageQueue(QueuePath, access);
if (formatter != null)
messageQueue.Formatter = formatter;
var openedQueue = new OpenedQueue(this, messageQueue, QueueUri.ToString(),Transactional)
{
Formatter = formatter
};
if (SubQueue != null)
return openedQueue.OpenSubQueue(SubQueue.Value, access);
return openedQueue;
}
public MessageQueue(string QueuePath, QueueAccessMode access)
{
this.QueuePath = QueuePath;
this.access = access;
}
public OpenedQueue OpenSiblngQueue(SubQueue subQueue, QueueAccessMode accessMode)
{
return(new OpenedQueue(info, new MessageQueue(info.QueuePath + "#" + subQueue), queueUrl + "#" + subQueue, transactional));
}
private QueueAccessModeHolder(QueueAccessMode accessMode)
{
this.accessMode = accessMode;
}
public MessageQueue(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode accessMode) {}
public OpenedQueue OpenSubQueue(SubQueue subQueue, QueueAccessMode access)
{
var messageQueue = new MessageQueue(info.QueuePath + ";" + subQueue);
if (Formatter != null)
messageQueue.Formatter = Formatter;
return new OpenedQueue(this, messageQueue, queueUrl+";"+subQueue);
}
private static MessageQueue CreateSubscriptionQueue(Uri subscriptionQueue, QueueAccessMode accessMode)
{
var description = MsmqUtil.GetQueuePath(subscriptionQueue);
MessageQueue queue;
try
{
queue = new MessageQueue(description, accessMode);
}
catch (Exception e)
{
throw new SubscriptionException("Could not open subscription queue (" + subscriptionQueue + ")", e);
}
queue.Formatter = new XmlMessageFormatter(new[] { typeof(string) });
return queue;
}
public static extern int OpenQueue(string formatName, QueueAccessMode access, QueueShareReceive shareMode, out QueueHandle handle);
public static MessageQueue Create(string queueFormatName, QueueAccessMode accessMode)
{
return(new MessageQueue(queueFormatName, false, true, accessMode));
}
private QueueAccessModeHolder(QueueAccessMode accessMode)
{
this.accessMode = accessMode;
}
/// <summary>
/// Initalise the message queue.
/// Setting up all options as required.
/// </summary>
internal void InitaliseMessageQueue(QueueAccessMode mode)
{
//Connect to the queue if needed
if (_MessageQueue == null || _MessageQueue.AccessMode != mode)
{
if(string.IsNullOrEmpty(QueueName)) throw new Exception("Queuename has not been set.");
_MessageQueue = new MessageQueue(QueueName, mode);
}
}
public MessageQueueImpl(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode accessMode)
{
_wrapped = new MessageQueue(path, sharedModeDenyReceive, enableCache, accessMode);
}
public MessageQueueImpl(string path, QueueAccessMode accessMode)
{
_wrapped = new MessageQueue(path, accessMode);
}
public MsmqBusOptions(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode queueAccessMode, bool useInternalTransaction)
{
this.SharedModeDenyReceive = sharedModeDenyReceive;
this.EnableCache = enableCache;
this.QueueAccessMode = queueAccessMode;
this.Path = path;
this.UseInternalTransaction = useInternalTransaction;
}
/// <summary>
/// Initializes a new instance of <see cref="MessageQueue"/>.
/// </summary>
/// <param name="path">The location of the queue referenced by this <see cref="MessageQueue"/>, which can be "<value>.</value>" for the local computer.</param>
/// <param name="accessMode">One of the <see cref="QueueAccessMode"/> values.</param>
public MessageQueue(String path, QueueAccessMode accessMode)
: base(path, sharedModeDenyReceive: false, enableCache: true, accessMode: accessMode)
{
}
public EnumerableMessageQueue(string path, QueueAccessMode accessMode)
: base(path, accessMode)
{
}
public OpenedQueue OpenSiblngQueue(SubQueue subQueue, QueueAccessMode accessMode)
{
return new OpenedQueue(info, new MessageQueue(info.QueuePath + "#" + subQueue), queueUrl + "#" + subQueue, transactional);
}
public MessageQueue (string path, QueueAccessMode accessMode) :
this (GetMessageQueue (path))
{
}
public static MessageQueue OpenOrCreateQueue(string newQueuePath, QueueAccessMode accessMode, MessageQueue parentQueue)
{
try
{
bool exists;
try
{
exists = MessageQueue.Exists(newQueuePath);
}
catch (InvalidOperationException)// probably a queue on a remote machine
{
return new MessageQueue(newQueuePath);
}
if (exists == false)
{
try
{
CreateQueue(newQueuePath, parentQueue.Transactional);
}
catch (Exception e)
{
throw new TransportException("Queue " + newQueuePath + " doesn't exists and we failed to create it", e);
}
}
return new MessageQueue(newQueuePath, accessMode);
}
catch (Exception e)
{
throw new MessagePublicationException("Could not open queue (" + newQueuePath + ")", e);
}
}
public static MessageQueue AsMessageQueue(this Queue queue, QueueAccessMode mode = QueueAccessMode.Receive)
{
return(new MessageQueue(queue.FormatName, mode));
}
public OpenedQueue Open(QueueAccessMode access)
{
return Open(access, null);
}
/// <inheritdoc />
public System.Messaging.MessageQueue Get(string serverName, string name, bool privateQueue, QueueAccessMode mode)
{
try
{
lock (_lock)
{
System.Messaging.MessageQueue.ClearConnectionCache();
return(Exists(serverName, name, privateQueue) ? new System.Messaging.MessageQueue(Path(serverName, name, privateQueue), mode) : null);
}
}
catch (MessageQueueException exception)
{
_logger.Warning(exception, "Error Getting Message Queue");
return(null);
}
}
public MessageQueue(string path, QueueAccessMode accessMode) {}
public CN100MessageQueue(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode accessMode)
: base(path, sharedModeDenyReceive, enableCache, accessMode)
{ }
public static MessageQueue Create(string queueFormatName, QueueAccessMode accessMode)
{
return new MessageQueue(queueFormatName, false, true, accessMode);
}
public MessageQueue(string path, QueueAccessMode accessMode) :
this(GetMessageQueue(path))
{
}
public OpenedQueue OpenSubQueue(OpenedQueue queue, SubQueue subQueue, QueueAccessMode accessMode)
{
return queue.OpenSubQueue(subQueue, accessMode);
}
public EnumerableMessageQueue(string path, bool sharedModeDenyReceive, bool enableCache, QueueAccessMode accessMode)
: base(path, sharedModeDenyReceive, enableCache, accessMode)
{
}
public static MessageQueue AsMessageQueue(this Queue queue, QueueAccessMode mode = QueueAccessMode.Receive)
{
return new MessageQueue(queue.FormatName, mode);
}
public CN100MessageQueue(string path, QueueAccessMode accessMode)
: base(path, accessMode)
{
}
private OpenedQueue CreateSubscriptionQueue(Uri subscriptionQueueUri, QueueAccessMode accessMode)
{
OpenedQueue queue;
try
{
var endpoint = endpointRouter.GetRoutedEndpoint(subscriptionQueueUri);
queue = MsmqUtil.GetQueuePath(endpoint).Open(accessMode, new XmlMessageFormatter(new[] { typeof(string) }));
}
catch (Exception e)
{
throw new SubscriptionException("Could not open subscription queue (" + subscriptionQueueUri + ")", e);
}
return queue;
}
public OpenedQueue OpenSubQueue(OpenedQueue queue, SubQueue subQueue, QueueAccessMode accessMode)
{
return(queue.OpenSiblngQueue(subQueue, accessMode));
}
