public Message Receive(MessageQueueTransactionType transactionType)
{
try
{
IMessage iMsg = delegateQueue.Receive((Mono.Messaging.MessageQueueTransactionType)transactionType);
if (iMsg == null)
{
return(null);
}
return(new Message(iMsg, null, Formatter));
}
catch (ConnectionException e)
{
throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message);
}
catch (MessageUnavailableException e)
{
throw new InvalidOperationException(e.Message, e);
}
catch (MonoMessagingException e)
{
throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message);
}
}
public string SendMessage(string message)
{
MessageQueue queueManager = null;
System.Messaging.Message messageToSend = new System.Messaging.Message();
try
{
queueManager = new MessageQueue(queueTXT.Text);
System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(messageToSend.BodyStream, System.Text.Encoding.Unicode);
streamWriter.Write(message);
streamWriter.Flush();
MessageQueueTransactionType mqTT = (MessageQueueTransactionType)Enum.Parse(typeof(MessageQueueTransactionType), comboBox1.Text);
queueManager.Send(messageToSend, msgLabelTXT.Text, mqTT);
}
catch (MessageQueueException ex)
{
throw;
}
finally
{
if (queueManager != null)
{
queueManager.Close();
}
}
return(messageToSend.Id);
}
private IMessage Run (MessageQueueTransactionType transactionType,
RecieveDelegate r)
{
switch (transactionType) {
case MessageQueueTransactionType.Single:
using (RabbitMQMessageQueueTransaction tx = GetTx ()) {
bool success = false;
try {
IMessage msg = Run (tx, r);
tx.Commit ();
success = true;
return msg;
} finally {
if (!success)
tx.Abort ();
}
}
case MessageQueueTransactionType.None:
return Run (r);
default:
throw new NotSupportedException(transactionType + " not supported");
}
}
public void Send(object obj, MessageQueueTransactionType transactionType)
{
if (typeof(Message) == obj.GetType())
{
Message m = (Message)obj;
if (m.BodyStream == null)
{
IMessageFormatter f = (m.Formatter == null) ? Formatter : m.Formatter;
f.Write(m, m.Body);
}
try
{
delegateQueue.Send(m.DelegateMessage, (Mono.Messaging.MessageQueueTransactionType)transactionType);
}
catch (ConnectionException e)
{
throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message);
}
catch (MonoMessagingException e)
{
throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message);
}
}
else
{
Message m = new Message(obj);
Send(m, transactionType);
}
}
public void Send(IMessage msg, MessageQueueTransactionType transactionType)
{
switch (transactionType)
{
case MessageQueueTransactionType.Single:
using (IMessageQueueTransaction tx = provider.CreateMessageQueueTransaction())
{
try
{
Send(msg, tx);
tx.Commit();
}
catch (Exception e)
{
tx.Abort();
throw new MonoMessagingException(e.Message, e);
}
}
break;
case MessageQueueTransactionType.None:
Send(msg);
break;
case MessageQueueTransactionType.Automatic:
throw new NotSupportedException("Automatic transaction types not supported");
}
}
public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType)
{
try
{
IMessage iMsg = delegateEnumerator.RemoveCurrent(timeout,
(Mono.Messaging.MessageQueueTransactionType)transactionType);
if (iMsg == null)
{
return(null);
}
return(new Message(iMsg, null, formatter));
}
catch (ConnectionException e)
{
throw new MessageQueueException(MessageQueueErrorCode.QueueNotAvailable, e.Message);
}
catch (MessageUnavailableException e)
{
throw new InvalidOperationException(e.Message, e);
}
catch (MonoMessagingException e)
{
throw new MessageQueueException(MessageQueueErrorCode.Generic, e.Message);
}
}
private IMessage DoReceive(MessageQueueTransactionType transactionType,
TimeSpan timeout, IsMatch matcher, bool ack)
{
switch (transactionType)
{
case MessageQueueTransactionType.Single:
using (RabbitMQMessageQueueTransaction tx = NewTx()) {
bool success = false;
try {
IMessage msg = DoReceive((IMessagingContext)tx, timeout, matcher, ack);
tx.Commit();
success = true;
return(msg);
} finally {
if (!success)
{
tx.Abort();
}
}
}
case MessageQueueTransactionType.None:
return(DoReceive(timeout, matcher, true));
default:
throw new NotSupportedException(transactionType + " not supported");
}
}
public MsmqMessageDeliveryQueue(string path, MessageQueueTransactionType transactionType, IMessageFormatter formatter)
{
_queue = new MessageQueue(path);
_formatter = new MessageDeliveryFormatter();
_transactionType = transactionType;
_formatter = formatter;
}
public void Send(Message message,
MessageQueueTransactionType transactionType)
{
this.message = message;
this.transactionType = transactionType;
numMessages++;
}
/// <summary>
/// Initializes a new instance of <see cref="MsmqTraceListener"/>.
/// </summary>
/// <param name="name">The name of the new instance.</param>
/// <param name="queuePath">The path to the queue to deliver to.</param>
/// <param name="formatter">The formatter to use.</param>
/// <param name="messagePriority">The priority for the messages to send.</param>
/// <param name="recoverable">The recoverable flag for the messages to send.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param>
/// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param>
/// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param>
/// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param>
/// <param name="useEncryption">The useEncryption flag for the messages to send.</param>
/// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param>
/// <param name="msmqInterfaceFactory">The factory to create the msmq interfaces.</param>
public MsmqTraceListener(string name,
string queuePath,
ILogFormatter formatter,
MessagePriority messagePriority,
bool recoverable,
TimeSpan timeToReachQueue,
TimeSpan timeToBeReceived,
bool useAuthentication,
bool useDeadLetterQueue,
bool useEncryption,
MessageQueueTransactionType transactionType,
IMsmqSendInterfaceFactory msmqInterfaceFactory)
: base(formatter)
{
this.queuePath = queuePath;
this.messagePriority = messagePriority;
this.recoverable = recoverable;
this.timeToReachQueue = timeToReachQueue;
this.timeToBeReceived = timeToBeReceived;
this.useAuthentication = useAuthentication;
this.useDeadLetterQueue = useDeadLetterQueue;
this.useEncryption = useEncryption;
this.transactionType = transactionType;
this.msmqInterfaceFactory = msmqInterfaceFactory;
}
public static void ReturnMessageToSourceQueue(string errorQueueMachine, string errorQueueName, string msmqMessageId)
{
string path = string.Format(@"{0}\private$\{1}", errorQueueMachine, errorQueueName);
MessageQueue errorQueue = new MessageQueue(path);
{
MessagePropertyFilter messageReadPropertyFilter = new MessagePropertyFilter
{
Body = true,
TimeToBeReceived = true,
Recoverable = true,
Id = true,
ResponseQueue = true,
CorrelationId = true,
Extension = true,
AppSpecific = true,
LookupId = true,
};
errorQueue.MessageReadPropertyFilter = messageReadPropertyFilter;
using (TransactionScope scope = new TransactionScope())
{
MessageQueueTransactionType transactionType = MessageQueueTransactionType.Automatic;
Message message = errorQueue.ReceiveById(msmqMessageId, TimeSpan.FromSeconds(5), transactionType);
string fullPath = ReadFailedQueueHeader(message);
using (MessageQueue failedQueue = new MessageQueue(fullPath))
{
failedQueue.Send(message, transactionType);
}
scope.Complete();
}
}
}
public MsmqMessageDeliveryQueue(string path, MessageQueueTransactionType transactionType, IMessageFormatter formatter)
{
_queue = new MessageQueue(path);
_formatter = new MessageDeliveryFormatter();
_transactionType = transactionType;
_formatter = formatter;
}
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value)
{
if ((value != MessageQueueTransactionType.None) && (value != MessageQueueTransactionType.Automatic))
{
return (value == MessageQueueTransactionType.Single);
}
return true;
}
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value)
{
if ((value != MessageQueueTransactionType.None) && (value != MessageQueueTransactionType.Automatic))
{
return(value == MessageQueueTransactionType.Single);
}
return(true);
}
protected void MovePoisonMessageToErrorQueue(Message message, MessageQueueTransactionType transactionType)
{
var error = $"Message '{message.Id}' is classified as a poison message and will be moved to the configured error queue.'";
Logger.Error(error);
errorQueue.Send(message, transactionType);
}
public MsmqRouterFactory(ILoggerContextSensitive log, TimeSpan waitMessageTimeout, Func <MessageQueueTransactionType> sendTransactionType, MessageQueueTransactionType receiveTransactionType)
{
_stopwatch = new Stopwatch();
_log = log;
_waitMessageTimeout = waitMessageTimeout;
_sendTransactionType = sendTransactionType;
_receiveTransactionType = receiveTransactionType;
}
protected override void SendMessage(MessageQueue queue, Message message)
{
MessageQueueTransactionType tt = (Transaction.Current != null)
? MessageQueueTransactionType.Automatic
: MessageQueueTransactionType.Single;
queue.Send(message, tt);
}
public Message Receive(TimeSpan fromSeconds, MessageQueueTransactionType transactionTypeForReceive)
{
var message = _messages.First();
_messages.Remove(message);
_processedMessages.Add(message);
return(message);
}
public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType)
{
if (!ValidationUtility.ValidateMessageQueueTransactionType(transactionType))
{
throw new InvalidEnumArgumentException("transactionType", (int)transactionType, typeof(MessageQueueTransactionType));
}
return(this.RemoveCurrent(timeout, null, transactionType));
}
/// <include file='doc\MessageEnumerator.uex' path='docs/doc[@for="MessageEnumerator.RemoveCurrent4"]/*' />
/// <devdoc>
/// <para> Removes the current message from
/// the queue and returns the message to the calling application within the timeout specified.</para>
/// </devdoc>
public Message RemoveCurrent(TimeSpan timeout, MessageQueueTransactionType transactionType)
{
if (!Enum.IsDefined(typeof(MessageQueueTransactionType), transactionType))
{
throw new InvalidEnumArgumentException("transactionType", (int)transactionType, typeof(MessageQueueTransactionType));
}
return(RemoveCurrent(timeout, null, transactionType));
}
/// <summary>
/// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class.
/// </summary>
/// <param name="name">The name for the represented trace listener.</param>
/// <param name="queuePath">The path name for the represented trace listener.</param>
/// <param name="formatterName">The formatter name for the represented trace listener.</param>
/// <param name="messagePriority">The priority for the represented trace listener.</param>
/// <param name="recoverable">The recoverable flag for the represented trace listener.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param>
/// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param>
/// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param>
/// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param>
/// <param name="useEncryption">The use encryption flag for the represented trace listener.</param>
/// <param name="transactionType">The transaction type for the represented trace listener.</param>
public MsmqTraceListenerData(string name, string queuePath, string formatterName,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType)
: this(name, queuePath, formatterName, messagePriority, recoverable, timeToReachQueue, timeToBeReceived,
useAuthentication, useDeadLetterQueue, useEncryption, transactionType, TraceOptions.None)
{
}
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value)
{
//
// note that MessageQueueTransactionType has disjoined values
//
return (value == MessageQueueTransactionType.None) ||
(value == MessageQueueTransactionType.Automatic) ||
(value == MessageQueueTransactionType.Single);
}
public static bool ValidateMessageQueueTransactionType(MessageQueueTransactionType value)
{
//
// note that MessageQueueTransactionType has disjoined values
//
return((value == MessageQueueTransactionType.None) ||
(value == MessageQueueTransactionType.Automatic) ||
(value == MessageQueueTransactionType.Single));
}
public void Send(Message message, string label, MessageQueueTransactionType transactionType)
{
_queue.Send(message, label, transactionType);
if (_autoPurgeSystemJournal && (_lastPurgedOn == DateTime.MinValue || _lastPurgedOn.AddMinutes(purgeIntervalInMinutes) < DateTime.Now))
{
systemJournalQueue.Purge();
_lastPurgedOn = DateTime.Now;
}
}
/// <summary>
/// Initializes a new instance of <see cref="MsmqTraceListener"/>.
/// </summary>
/// <param name="name">The name of the new instance.</param>
/// <param name="queuePath">The path to the queue to deliver to.</param>
/// <param name="formater">The formatter to use.</param>
/// <param name="messagePriority">The priority for the messages to send.</param>
/// <param name="recoverable">The recoverable flag for the messages to send.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param>
/// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param>
/// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param>
/// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param>
/// <param name="useEncryption">The useEncryption flag for the messages to send.</param>
/// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param>
public MsmqTraceListener(string name, string queuePath, ILogFormatter formater,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType)
: this(name, queuePath, formater, messagePriority, recoverable,
timeToReachQueue, timeToBeReceived,
useAuthentication, useDeadLetterQueue, useEncryption,
transactionType, new MsmqSendInterfaceFactory())
{
}
/// <summary>
/// Initializes a new instance of <see cref="MsmqTraceListener"/>.
/// </summary>
/// <param name="name">The name of the new instance.</param>
/// <param name="queuePath">The path to the queue to deliver to.</param>
/// <param name="formater">The formatter to use.</param>
/// <param name="messagePriority">The priority for the messages to send.</param>
/// <param name="recoverable">The recoverable flag for the messages to send.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param>
/// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param>
/// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param>
/// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param>
/// <param name="useEncryption">The useEncryption flag for the messages to send.</param>
/// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param>
public MsmqTraceListener(string name, string queuePath, ILogFormatter formater,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType)
: this(name, queuePath, formater, messagePriority, recoverable,
timeToReachQueue, timeToBeReceived,
useAuthentication, useDeadLetterQueue, useEncryption,
transactionType, new MsmqSendInterfaceFactory())
{
}
public static void PushTripStatus(string TripID, EventDef aEvent)
{
MessageQueue queue = GetQueue(TripQueue, QueueAccessMode.Send);
MessageQueueTransactionType txnType = MessageQueueTransactionType.Single;
MQBatchRequest mqBatchRequest = new MQBatchRequest()
{
EventType = aEvent,
MessageData = TripID,
QueueTarget = TripQueue
};
queue.Send(mqBatchRequest, txnType);
}
public void Send(object obj, string label, MessageQueueTransactionType transactionType)
{
if (typeof(Message) == obj.GetType())
{
Message m = (Message)obj;
m.Label = label;
Send(m, transactionType);
}
else
{
Message m = new Message(obj);
Send(m, label, transactionType);
}
}
private void SendMsmqMesage(string serializedEntry)
{
lock (syncObject)
{
using (MessageQueue messageQueue = new MessageQueue(msmqDistributionStrategyData.QueuePath))
{
MessageQueueTransactionType transactionType = (messageQueue.Transactional)
? MessageQueueTransactionType.Single
: MessageQueueTransactionType.None;
messageQueue.Formatter = new XmlMessageFormatter();
messageQueue.Send(serializedEntry, transactionType);
messageQueue.Close();
}
}
}
/// <summary>
/// ITestStep.Execute() implementation
/// </summary>
/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
public void Execute(XmlNode testConfig, Context context)
{
MemoryStream msgStr = null;
try
{
// read test config...
string sourcePath = context.ReadConfigAsString(testConfig, "SourcePath");
string queuePath = context.ReadConfigAsString(testConfig, "QueuePath");
string messageLabel = context.ReadConfigAsString(testConfig, "MessageLabel");
string correlationId = context.ReadConfigAsString(testConfig, "CorrelationId", true);
int appSpecific = context.ReadConfigAsInt32(testConfig, "AppSpecific", true);
object objUseTransactions = context.ReadConfigAsObject(testConfig, "UseTransactions", true);
if (null != objUseTransactions)
{
if (!Convert.ToBoolean(objUseTransactions))
{
_transactionType = MessageQueueTransactionType.None;
}
}
context.LogInfo("MSMQWriteStep about to write data from File: {0} to the queue: {1}", sourcePath, queuePath);
var queue = new MessageQueue(queuePath);
var msg = new Message();
msgStr = StreamHelper.LoadFileToStream(sourcePath);
msg.BodyStream = msgStr;
msg.UseDeadLetterQueue = true;
if (null != correlationId)
{
msg.CorrelationId = correlationId;
}
msg.AppSpecific = appSpecific;
queue.Send(msg, messageLabel, _transactionType);
}
finally
{
if (null != msgStr)
{
msgStr.Close();
}
}
}
public override void Execute(Context context)
{
_request = MessageBody.Load(context);
context.LogXmlData("Message", _request, true);
try
{
if (!UseTransactions)
{
_transactionType = MessageQueueTransactionType.None;
}
context.LogInfo("MSMQWriteStep about to write data to the queue: {0}", QueuePath);
var queue = new MessageQueue(MSMQHelper.DeNormalizeQueueName(QueuePath));
var msg = new Message();
if (BodyType == VarEnum.VT_EMPTY)
{
msg.BodyStream = _request;
}
else
{
msg.BodyType = (int)BodyType;
var formatter = new ActiveXMessageFormatter();
formatter.Write(msg, Common.StreamHelper.WriteStreamToString(_request));
}
msg.UseDeadLetterQueue = true;
if (!string.IsNullOrEmpty(CorrelationId))
{
msg.CorrelationId = CorrelationId;
}
msg.AppSpecific = AppSpecific;
queue.Send(msg, MessageLabel, _transactionType);
}
finally
{
if (null != _request)
{
_request.Close();
}
}
}
public static void PushTripInfo(string TripID, int EmployeeID, EventDef aEvent)
{
MessageQueue queue = GetQueue(TripQueue, QueueAccessMode.Send);
MessageQueueTransactionType txnType = MessageQueueTransactionType.Single;
MQBatchRequest mqBatchRequest = new MQBatchRequest()
{
EventType = aEvent,
MessageData = new TripPersonUpdate()
{
TripID = TripID,
EmployeeID = EmployeeID
},
QueueTarget = TripQueue
};
queue.Send(mqBatchRequest, txnType);
}
/// <summary>
/// Initialize a new instance of the <see cref="MsmqTraceListenerNode"/> class with a <see cref="MsmqTraceListenerData"/> instance.
/// </summary>
/// <param name="msmqTraceListenerData">A <see cref="MsmqTraceListenerData"/> instance.</param>
public MsmqTraceListenerNode(MsmqTraceListenerData msmqTraceListenerData)
{
if (null == msmqTraceListenerData) throw new ArgumentNullException("msmqTraceListenerData");
Rename(msmqTraceListenerData.Name);
TraceOutputOptions = msmqTraceListenerData.TraceOutputOptions;
this.useEncryption = msmqTraceListenerData.UseEncryption;
this.useDeadLetterQueue = msmqTraceListenerData.UseDeadLetterQueue;
this.useAuthentication = msmqTraceListenerData.UseAuthentication;
this.transactionType = msmqTraceListenerData.TransactionType;
this.messagePriority = msmqTraceListenerData.MessagePriority;
this.timeToReachQueue = msmqTraceListenerData.TimeToReachQueue;
this.timeToBeReceived = msmqTraceListenerData.TimeToBeReceived;
this.recoverable = msmqTraceListenerData.Recoverable;
this.queuePath = msmqTraceListenerData.QueuePath;
this.formatterName = msmqTraceListenerData.Formatter;
}
/// <summary>
/// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class.
/// </summary>
/// <param name="name">The name for the represented trace listener.</param>
/// <param name="queuePath">The path name for the represented trace listener.</param>
/// <param name="formatterName">The formatter name for the represented trace listener.</param>
/// <param name="messagePriority">The priority for the represented trace listener.</param>
/// <param name="recoverable">The recoverable flag for the represented trace listener.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param>
/// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param>
/// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param>
/// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param>
/// <param name="useEncryption">The use encryption flag for the represented trace listener.</param>
/// <param name="transactionType">The transaction type for the represented trace listener.</param>
/// <param name="traceOutputOptions">The trace output options for the represented trace listener.</param>
public MsmqTraceListenerData(string name, string queuePath, string formatterName,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType, TraceOptions traceOutputOptions)
: base(name, typeof(MsmqTraceListener), traceOutputOptions)
{
this.QueuePath = queuePath;
this.Formatter = formatterName;
this.MessagePriority = messagePriority;
this.Recoverable = recoverable;
this.TimeToReachQueue = timeToReachQueue;
this.TimeToBeReceived = timeToBeReceived;
this.UseAuthentication = useAuthentication;
this.UseDeadLetterQueue = useDeadLetterQueue;
this.UseEncryption = useEncryption;
this.TransactionType = transactionType;
}
public static void Queue(BatchRequest batchRequest)
{
try
{
MessageQueue queue = GetQueue(batchRequest.QueueTarget, QueueAccessMode.Send);
MessageQueueTransactionType txnType = MessageQueueTransactionType.Single;
if (queue.CanWrite == false)
{
throw new Exception("PhysicalQueueNotFound: " + batchRequest.QueueTarget);
}
queue.Send(batchRequest, txnType);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Initializes a new instance of <see cref="MsmqTraceListener"/>.
/// </summary>
/// <param name="name">The name of the new instance.</param>
/// <param name="queuePath">The path to the queue to deliver to.</param>
/// <param name="formater">The formatter to use.</param>
/// <param name="messagePriority">The priority for the messages to send.</param>
/// <param name="recoverable">The recoverable flag for the messages to send.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the messages to send.</param>
/// <param name="timeToBeReceived">The timeToBeReceived for the messages to send.</param>
/// <param name="useAuthentication">The useAuthentication flag for the messages to send.</param>
/// <param name="useDeadLetterQueue">The useDeadLetterQueue flag for the messages to send.</param>
/// <param name="useEncryption">The useEncryption flag for the messages to send.</param>
/// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> for the message to send.</param>
/// <param name="msmqInterfaceFactory">The factory to create the msmq interfaces.</param>
public MsmqTraceListener(string name, string queuePath, ILogFormatter formater,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType,
IMsmqSendInterfaceFactory msmqInterfaceFactory)
: base(formater)
{
this.queuePath = queuePath;
this.messagePriority = messagePriority;
this.recoverable = recoverable;
this.timeToReachQueue = timeToReachQueue;
this.timeToBeReceived = timeToBeReceived;
this.useAuthentication = useAuthentication;
this.useDeadLetterQueue = useDeadLetterQueue;
this.useEncryption = useEncryption;
this.transactionType = transactionType;
this.msmqInterfaceFactory = msmqInterfaceFactory;
}
protected bool TryReceive(MessageQueueTransactionType transactionType, out Message message)
{
try
{
message = inputQueue.Receive(TimeSpan.FromMilliseconds(10), transactionType);
return true;
}
catch (MessageQueueException ex)
{
if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout)
{
//We should only get an IOTimeout exception here if another process removed the message between us peeking and now.
message = null;
return false;
}
throw;
}
}
public void Send (object obj, MessageQueueTransactionType transactionType)
{
if (typeof (Message) == obj.GetType ()) {
Message m = (Message) obj;
if (m.BodyStream == null) {
IMessageFormatter f = (m.Formatter == null) ? Formatter : m.Formatter;
f.Write (m, m.Body);
}
try {
delegateQueue.Send (m.DelegateMessage, (Mono.Messaging.MessageQueueTransactionType) transactionType);
} catch (ConnectionException e) {
throw new MessageQueueException (MessageQueueErrorCode.QueueNotAvailable, e.Message);
} catch (MonoMessagingException e) {
throw new MessageQueueException (MessageQueueErrorCode.Generic, e.Message);
}
} else {
Message m = new Message (obj);
Send (m, transactionType);
}
}
public void Send(object obj, string label, MessageQueueTransactionType transactionType) {}
public void Send(Message message, MessageQueueTransactionType transactionType)
{
this.message = message;
this.transactionType = transactionType;
numMessages++;
}
/// <summary>
/// Receives the current message in the queue, using a specified cursor. If no message is available, this method waits until either a message is available, or the time-out expires.
/// </summary>
/// <returns>
/// A <see cref="T:System.Messaging.Message"/> that references a message in the queue.
/// </returns>
/// <param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="cursor">A <see cref="T:System.Messaging.Cursor"/> that maintains a specific position in the message queue.</param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values that describes the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="cursor"/> parameter is null.</exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid. Possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><exception cref="T:System.Messaging.MessageQueueException">A message did not arrive in the queue before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception>
public Message Receive(TimeSpan timeout, Cursor cursor, MessageQueueTransactionType transactionType)
{
return _queue.Receive(timeout, cursor, transactionType);
}
public void Send(object obj, MessageQueueTransactionType transactionType) {}
public Message ReceiveByCorrelationId(string correlationId, MessageQueueTransactionType transactionType) {}
/// <summary>
/// Sends a message to the underlying MSMQ.
/// </summary>
/// <param name="message">The <see cref="Message"/> to send.</param>
/// <param name="transactionType">The <see cref="MessageQueueTransactionType"/> value that specifies the type of transaciton to use.</param>
public void Send(Message message, MessageQueueTransactionType transactionType)
{
messageQueue.Send(message, transactionType);
}
/// <summary>
/// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class.
/// </summary>
/// <param name="name">The name for the represented trace listener.</param>
/// <param name="queuePath">The path name for the represented trace listener.</param>
/// <param name="formatterName">The formatter name for the represented trace listener.</param>
/// <param name="messagePriority">The priority for the represented trace listener.</param>
/// <param name="recoverable">The recoverable flag for the represented trace listener.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param>
/// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param>
/// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param>
/// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param>
/// <param name="useEncryption">The use encryption flag for the represented trace listener.</param>
/// <param name="transactionType">The transaction type for the represented trace listener.</param>
public MsmqTraceListenerData(string name, string queuePath, string formatterName,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType)
: this(name, queuePath, formatterName, messagePriority, recoverable, timeToReachQueue, timeToBeReceived,
useAuthentication, useDeadLetterQueue, useEncryption, transactionType, TraceOptions.None, SourceLevels.All)
{
}
/// <summary>
/// Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.
/// </summary>
/// <returns>
/// The <see cref="T:System.Messaging.Message"/> whose <see cref="P:System.Messaging.Message.Id"/> property matches the <paramref name="id"/> parameter passed in.
/// </returns>
/// <param name="id">The <see cref="P:System.Messaging.Message.Id"/> of the message to receive. </param><param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="id"/> parameter is null. </exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid, possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.Messaging.MessageQueueException">A message with the specified <paramref name="id"/> did not arrive in the queue before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet>
public Message ReceiveById(string id, TimeSpan timeout, MessageQueueTransactionType transactionType)
{
return _queue.ReceiveById(id, timeout, transactionType);
}
/// <summary>
/// Introduced in MSMQ 3.0. Receives a specific message from the queue, using the specified transaction context. The message can be specified by a lookup identifier or by its position at the front or end of the queue.
/// </summary>
/// <returns>
/// The <see cref="T:System.Messaging.Message"/> specified by the <paramref name="action"/> and <paramref name="lookupId"/> parameters passed in.
/// </returns>
/// <param name="action">One of the <see cref="T:System.Messaging.MessageLookupAction"/> values, specifying how the message is read in the queue. Specify one of the following:MessageLookupAction.Current: Receives the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.Next: Receives the message following the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.Previous: Receives the message preceding the message specified by <paramref name="lookupId"/> and removes it from the queue.MessageLookupAction.First: Receives the first message in the queue and removes it from the queue. The <paramref name="lookupId"/> parameter must be set to 0.MessageLookupAction.Last: Receives the last message in the queue and removes it from the queue. The <paramref name="lookupId"/> parameter must be set to 0.</param><param name="lookupId">The <see cref="P:System.Messaging.Message.LookupId"/> of the message to receive, or 0. 0 is used when accessing the first or last message in the queue. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message.</param><exception cref="T:System.PlatformNotSupportedException">MSMQ 3.0 is not installed.</exception><exception cref="T:System.InvalidOperationException">The message with the specified <paramref name="lookupId"/> could not be found. </exception><exception cref="T:System.Messaging.MessageQueueException">An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="action"/> parameter is not one of the <see cref="T:System.Messaging.MessageLookupAction"/> members.-or- The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members.</exception>
public Message ReceiveByLookupId(MessageLookupAction action, long lookupId, MessageQueueTransactionType transactionType)
{
return _queue.ReceiveByLookupId(action, lookupId, transactionType);
}
public Message Receive(MessageQueueTransactionType transactionType) {}
/// <summary>
/// Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.
/// </summary>
/// <returns>
/// The <see cref="T:System.Messaging.Message"/> whose <see cref="P:System.Messaging.Message.CorrelationId"/> matches the <paramref name="correlationId"/> parameter passed in.
/// </returns>
/// <param name="correlationId">The <see cref="P:System.Messaging.Message.CorrelationId"/> of the message to receive. </param><param name="timeout">A <see cref="T:System.TimeSpan"/> that indicates the time to wait until a new message is available for inspection. </param><param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.ArgumentNullException">The <paramref name="correlationId"/> parameter is null. </exception><exception cref="T:System.InvalidOperationException">The message with the specified <paramref name="correlationId"/> could not be found. </exception><exception cref="T:System.ArgumentException">The value specified for the <paramref name="timeout"/> parameter is not valid, possibly <paramref name="timeout"/> is less than <see cref="F:System.TimeSpan.Zero"/> or greater than <see cref="F:System.Messaging.MessageQueue.InfiniteTimeout"/>. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><exception cref="T:System.Messaging.MessageQueueException">The message with the specified <paramref name="correlationId"/> does not exist in the queue and did not arrive before the time-out expired.-or- An error occurred when accessing a Message Queuing method. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet>
public Message ReceiveByCorrelationId(string correlationId, TimeSpan timeout, MessageQueueTransactionType transactionType)
{
return _queue.ReceiveByCorrelationId(correlationId, timeout, transactionType);
}
public void Send (object obj, string label, MessageQueueTransactionType transactionType)
{
if (typeof (Message) == obj.GetType ()) {
Message m = (Message) obj;
m.Label = label;
Send (m, transactionType);
} else {
Message m = new Message (obj);
Send (m, label, transactionType);
}
}
public Message ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}
public Message ReceiveById (string id, TimeSpan timeout, MessageQueueTransactionType transactionType)
{
try {
IMessage iMsg = delegateQueue.ReceiveById (id, timeout, (Mono.Messaging.MessageQueueTransactionType) transactionType);
if (iMsg == null)
return null;
return new Message (iMsg, null, Formatter);
} catch (ConnectionException e) {
throw new MessageQueueException (MessageQueueErrorCode.QueueNotAvailable, e.Message);
} catch (MessageUnavailableException e) {
throw new InvalidOperationException (e.Message, e);
} catch (MonoMessagingException e) {
throw new MessageQueueException (MessageQueueErrorCode.Generic, e.Message);
}
}
public Message ReceiveByLookupId(MessageLookupAction action, long lookupId, MessageQueueTransactionType transactionType) {}
public Message Receive(System.TimeSpan timeout, Cursor cursor, MessageQueueTransactionType transactionType) {}
/// <summary>
/// Receives the first message available in the queue referenced by the <see cref="T:System.Messaging.MessageQueue"/>. This call is synchronous, and blocks the current thread of execution until a message is available.
/// </summary>
/// <returns>
/// A <see cref="T:System.Messaging.Message"/> that references the first message available in the queue.
/// </returns>
/// <param name="transactionType">One of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> values, describing the type of transaction context to associate with the message. </param><exception cref="T:System.Messaging.MessageQueueException">An error occurred when accessing a Message Queuing method. </exception><exception cref="T:System.ComponentModel.InvalidEnumArgumentException">The <paramref name="transactionType"/> parameter is not one of the <see cref="T:System.Messaging.MessageQueueTransactionType"/> members. </exception><PermissionSet><IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence"/><IPermission class="System.Messaging.MessageQueuePermission, System.Messaging, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" version="1" Unrestricted="true"/><IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/></PermissionSet>
public Message Receive(MessageQueueTransactionType transactionType)
{
return _queue.Receive(transactionType);
}
public Message ReceiveById(string id, MessageQueueTransactionType transactionType) {}
public Message ReceiveById(string id, System.TimeSpan timeout, MessageQueueTransactionType transactionType) {}
/// <summary>
/// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class.
/// </summary>
/// <param name="name">The name for the represented trace listener.</param>
/// <param name="queuePath">The path name for the represented trace listener.</param>
/// <param name="formatterName">The formatter name for the represented trace listener.</param>
/// <param name="messagePriority">The priority for the represented trace listener.</param>
/// <param name="recoverable">The recoverable flag for the represented trace listener.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param>
/// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param>
/// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param>
/// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param>
/// <param name="useEncryption">The use encryption flag for the represented trace listener.</param>
/// <param name="transactionType">The transaction type for the represented trace listener.</param>
/// <param name="traceOutputOptions">The trace output options for the represented trace listener.</param>
/// <param name="filter">The filter for the represented trace listener.</param>
public MsmqTraceListenerData(string name, string queuePath, string formatterName,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType, TraceOptions traceOutputOptions, SourceLevels filter)
: base(name, typeof(MsmqTraceListener), traceOutputOptions, filter)
{
this.QueuePath = queuePath;
this.Formatter = formatterName;
this.MessagePriority = messagePriority;
this.Recoverable = recoverable;
this.TimeToReachQueue = timeToReachQueue;
this.TimeToBeReceived = timeToBeReceived;
this.UseAuthentication = useAuthentication;
this.UseDeadLetterQueue = useDeadLetterQueue;
this.UseEncryption = useEncryption;
this.TransactionType = transactionType;
}
public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
MessageQueueTransactionType transactionType)
{
return Run (transactionType, Receiver (timeout, ByCorrelationId (id)));
}
