public static void ReturnMessageToSourceQueue(string errorQueueMachine, string errorQueueName, string msmqMessageId)
{
var path = $@"{errorQueueMachine}\private$\{errorQueueName}";
var errorQueue = new MessageQueue(path);
{
var 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 (var scope = new TransactionScope())
{
var transactionType = MessageQueueTransactionType.Automatic;
var message = errorQueue.ReceiveById(msmqMessageId, TimeSpan.FromSeconds(5), transactionType);
var fullPath = ReadFailedQueueHeader(message);
using (var failedQueue = new MessageQueue(fullPath))
{
failedQueue.Send(message, transactionType);
}
scope.Complete();
}
}
}
void ITransport.Start()
{
if (hasStarted)
{
return;
}
lock (startLock)
{
if (hasStarted)
{
return;
}
InitQueue();
if (ErrorQueue != null)
{
errorQueue = new MessageQueue(MsmqUtilities.GetFullPath(ErrorQueue));
}
localQueue = new MessageQueue(MsmqUtilities.GetFullPath(InputQueue));
var mpf = new MessagePropertyFilter();
mpf.SetAll();
localQueue.MessageReadPropertyFilter = mpf;
if (MaxConcurrency > 0)
{
Task.Factory.StartNew(LoopAndReceiveMessage, TaskCreationOptions.LongRunning);
}
hasStarted = true;
}
}
public IEnumerable <MessageDescriptor> Tail(string queue)
{
var messagePropertyFilter = new MessagePropertyFilter
{
ArrivedTime = true,
Body = true,
Id = true,
Label = true
};
var messageQueue = new MessageQueue(queue);
messageQueue.MessageReadPropertyFilter = messagePropertyFilter;
var messageEnumerator2 = messageQueue.GetMessageEnumerator2();
while (true)
{
//arbitrary, 1 day.
while (messageEnumerator2.MoveNext(TimeSpan.FromDays(1)))
{
if (messageEnumerator2.Current == null)
{
continue;
}
yield return(CreateMessageDescriptor(messageEnumerator2.Current));
}
}
}
public void Init(Address address, bool transactional)
{
useTransactions = transactional;
if (address == null)
{
throw new ArgumentException("Input queue must be specified");
}
var machine = address.Machine;
if (machine.ToLower() != Environment.MachineName.ToLower())
{
throw new InvalidOperationException(string.Format("Input queue [{0}] must be on the same machine as this process [{1}].",
address, Environment.MachineName.ToLower()));
}
myQueue = new MessageQueue(MsmqUtilities.GetFullPath(address));
if (useTransactions && !QueueIsTransactional())
{
throw new ArgumentException("Queue must be transactional (" + address + ").");
}
var mpf = new MessagePropertyFilter();
mpf.SetAll();
myQueue.MessageReadPropertyFilter = mpf;
if (PurgeOnStartup)
{
myQueue.Purge();
}
}
private static MessageQueue InitializeQueue(MessageQueue q)
{
bool transactional;
try
{
transactional = q.Transactional;
}
catch (Exception ex)
{
throw new InvalidOperationException(
string.Format("There is a problem with the input queue given: {0}. See the enclosed exception for details.", q.Path),
ex);
}
if (!transactional)
{
throw new ArgumentException("Queue must be transactional (" + q.Path + ").");
}
var mpf = new MessagePropertyFilter();
mpf.SetAll();
q.MessageReadPropertyFilter = mpf;
return(q);
}
/// <summary>
/// Ppopulates the Message Browsing column list.
/// </summary>
private void SetupMessageBrowserPage()
{
//set up control properties
messageBrowsingUpButton.Tag = true;
messageBrowsingDownButton.Tag = false;
SetMessageBrowserListViewCommonProperties(messageBrowsingColumnsAvailableListView);
SetMessageBrowserListViewCommonProperties(messageBrowsingColumnsSelectedListView);
//load a list of message filter properties
MessagePropertyFilter filter = new MessagePropertyFilter();
PropertyInfo[] propertyInfoArray = filter.GetType().GetProperties();
foreach (PropertyInfo property in propertyInfoArray)
{
if (!Utilities.IsStringInArray(Constants.MessageBrowserColumnExclusionList, property.Name))
{
//create new available column list item
ListViewItem propertyListItem = new ListViewItem(property.Name);
messageBrowsingColumnsAvailableListView.Items.Add(propertyListItem);
}
}
//auto select properties/columns according to user settings
foreach (string columnName in _settings.MessageBrowserColumnListCollection)
{
foreach (ListViewItem checkItem in messageBrowsingColumnsAvailableListView.Items)
{
if (checkItem.Text == columnName)
{
AddMessageBrowsingColumn(checkItem);
break;
}
}
}
}
public MsmqReturnJournalObserver()
{
_log = Log.For(this);
_messagePropertyFilter = new MessagePropertyFilter();
_messagePropertyFilter.SetAll();
}
public void SetUp(string queuePath)
{
if (string.IsNullOrEmpty(queuePath))
{
throw new ArgumentNullException();
}
bool msmqExist;
try
{
msmqExist = MessageQueue.Exists(queuePath);
}
catch (InvalidOperationException)
{
msmqExist = true;
}
_messageQueue = !msmqExist
? MessageQueue.Create(queuePath, false)
: new MessageQueue(queuePath, false, true, QueueAccessMode.Receive);
_messageQueue.Formatter = new JsonGzipMessageFormatter <T>();
var filter = new MessagePropertyFilter();
filter.ClearAll();
filter.Body = true;
_messageQueue.MessageReadPropertyFilter = filter;
}
public void Connect()
{
Disconnect();
_log.DebugFormat("Creating MessageQueue: " + _formatName);
_queue = new MessageQueue(_formatName, _accessMode);
if (_multicastAddress != null)
{
_queue.MulticastAddress = _multicastAddress;
}
//https://connect.microsoft.com/VisualStudio/feedback/details/736877/msmq-multicast-in-system-messaging
// ReSharper disable EmptyGeneralCatchClause
// ReSharper disable UnusedVariable
try { var touch = _queue.FormatName; } catch { }
// ReSharper restore UnusedVariable
// ReSharper restore EmptyGeneralCatchClause
var filter = new MessagePropertyFilter();
filter.SetAll();
_queue.MessageReadPropertyFilter = filter;
}
//**************************************************
// Retrieves application-specific properties for a
// Message.
//**************************************************
public void RetrieveSelectedProperties()
{
// Connect to a message queue.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Specify to retrieve selected properties.
MessagePropertyFilter myFilter = new
MessagePropertyFilter();
myFilter.ClearAll();
// The following list is a random subset of available properties.
myFilter.Body = true;
myFilter.Label = true;
myFilter.MessageType = true;
myFilter.Priority = true;
myQueue.MessageReadPropertyFilter = myFilter;
// Set the formatter for the Message.
myQueue.Formatter = new XmlMessageFormatter(new Type[]
{ typeof(String) });
// Receive the first message in the queue.
Message myMessage = myQueue.Receive();
// Display selected properties.
Console.WriteLine("Message type: " +
myMessage.MessageType.ToString());
Console.WriteLine("Priority: " +
myMessage.Priority.ToString());
return;
}
public MsmqReleaseMessageObserver()
{
_log = Log.For(this);
_messagePropertyFilter = new MessagePropertyFilter();
_messagePropertyFilter.SetAll();
}
public void Init()
{
lock (lockObj)
{
if (storageQueue != null)
{
return;
}
var storageQueueAddress = configure.LocalAddress.SubScope("distributor.storage");
var path = MsmqUtilities.GetFullPath(storageQueueAddress);
var messageReadPropertyFilter = new MessagePropertyFilter
{
Id = true,
Label = true,
ResponseQueue = true,
};
storageQueue = new MessageQueue(path, false, true, QueueAccessMode.SendAndReceive)
{
MessageReadPropertyFilter = messageReadPropertyFilter
};
if ((!storageQueue.Transactional) && (configure.Settings.Get <bool>("Transactions.Enabled")))
{
throw new Exception(string.Format("Queue [{0}] must be transactional.", path));
}
}
}
public GxQueue(IGxContext context)
{
this.context = context;
this.queryString = "";
propertyFilter = new MessagePropertyFilter();
propertyFilter.SetDefaults();
propertyFilter.CorrelationId = true;
propertyFilter.Priority = true;
}
public static uint GetCount(this MessageQueue queue)
{
var flags = new MessagePropertyFilter
{
AdministrationQueue = false,
ArrivedTime = false,
CorrelationId = false,
Priority = false,
ResponseQueue = false,
SentTime = false,
Body = false,
Label = false,
Id = false,
AcknowledgeType = false,
Acknowledgment = false,
AppSpecific = false,
AttachSenderId = false,
Authenticated = false,
AuthenticationProviderName = false,
AuthenticationProviderType = false,
ConnectorType = false,
DestinationQueue = false,
DestinationSymmetricKey = false,
DigitalSignature = false,
EncryptionAlgorithm = false,
Extension = false,
HashAlgorithm = false,
IsFirstInTransaction = false,
IsLastInTransaction = false,
LookupId = false,
MessageType = false,
Recoverable = false,
SenderCertificate = false,
SenderId = false,
SenderVersion = false,
SourceMachine = false,
TimeToBeReceived = false,
TimeToReachQueue = false,
TransactionId = false,
TransactionStatusQueue = false,
UseAuthentication = false,
UseDeadLetterQueue = false,
UseEncryption = false,
UseJournalQueue = false,
UseTracing = false
};
var newQueue = new MessageQueue(queue.Path);
newQueue.MessageReadPropertyFilter = flags;
return((uint)newQueue.GetAllMessages()
.Length);
//return GetCount(queue.Path);
}
private MessagePropertyFilter GetMessageReadPropertyFilter()
{
var messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.CorrelationId = true;
messagePropertyFilter.Label = true;
messagePropertyFilter.AppSpecific = true;
messagePropertyFilter.Priority = true;
messagePropertyFilter.Extension = true;
return(messagePropertyFilter);
}
private MessageQueue CreateGuardedQueue()
{
var messageQueue = new MessageQueue(path);
var messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.SetAll();
messageQueue.MessageReadPropertyFilter = messagePropertyFilter;
return(messageQueue);
}
/// <summary>
/// Initializes the <see cref="IDequeueMessages" />.
/// </summary>
/// <param name="address">The address to listen on.</param>
/// <param name="settings">The <see cref="TransactionSettings" /> to be used by <see cref="IDequeueMessages" />.</param>
/// <param name="tryProcessMessage">Called when a message has been dequeued and is ready for processing.</param>
/// <param name="endProcessMessage">
/// Needs to be called by <see cref="IDequeueMessages" /> after the message has been
/// processed regardless if the outcome was successful or not.
/// </param>
public void Init(Address address, TransactionSettings settings, Func <TransportMessage, bool> tryProcessMessage,
Action <TransportMessage, Exception> endProcessMessage)
{
this.tryProcessMessage = tryProcessMessage;
this.endProcessMessage = endProcessMessage;
transactionSettings = settings;
if (address == null)
{
throw new ArgumentException("Input queue must be specified");
}
if (!address.Machine.Equals(RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException(
string.Format("Input queue [{0}] must be on the same machine as this process [{1}].",
address, RuntimeEnvironment.MachineName));
}
transactionOptions = new TransactionOptions
{
IsolationLevel = transactionSettings.IsolationLevel,
Timeout = transactionSettings.TransactionTimeout
};
queue = new MessageQueue(MsmqUtilities.GetFullPath(address), false, true, QueueAccessMode.Receive);
if (transactionSettings.IsTransactional && !QueueIsTransactional())
{
throw new ArgumentException(
"Queue must be transactional if you configure your endpoint to be transactional (" + address + ").");
}
var messageReadPropertyFilter = new MessagePropertyFilter
{
Body = true,
TimeToBeReceived = true,
Recoverable = true,
Id = true,
ResponseQueue = true,
CorrelationId = true,
Extension = true,
AppSpecific = true
};
queue.MessageReadPropertyFilter = messageReadPropertyFilter;
if (PurgeOnStartup)
{
queue.Purge();
}
}
private static void CheckNumberOfMessages(object state)
{
timer.Change(int.MaxValue, int.MaxValue);
Stopwatch watch = new Stopwatch();
watch.Start();
List <ManagedEndpoint> myList;
lock (typeof(Manager))
myList = new List <ManagedEndpoint>(endpoints);
foreach (ManagedEndpoint endpoint in myList)
{
MSMQ.MSMQManagementClass qMgmt = new MSMQ.MSMQManagementClass();
object machine = Type.Missing;
object missing = Type.Missing;
object formatName = "DIRECT=OS:" + Environment.MachineName + "\\private$\\" + endpoint.Queue;
try
{
qMgmt.Init(ref machine, ref missing, ref formatName);
endpoint.SetNumberOfMessages(qMgmt.MessageCount);
MessageQueue q = new MessageQueue("FormatName:" + formatName as string);
MessagePropertyFilter mpf = new MessagePropertyFilter();
mpf.SetAll();
q.MessageReadPropertyFilter = mpf;
Message m = q.Peek();
if (m != null)
{
endpoint.AgeOfOldestMessage = DateTime.Now - m.SentTime;
}
}
catch
{
//intentionally swallow bad endpoints
}
}
watch.Stop();
long due = refreshInterval * 1000 - watch.ElapsedMilliseconds;
due = (due < 0 ? 0 : due);
timer.Change(due, refreshInterval * 1000);
}
internal static void SetPropertyFilter(this MessageQueue messageQueue)
{
// Specify which MSMQ Message properties to retrieve
var messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.ClearAll();
messagePropertyFilter.Id = true;
messagePropertyFilter.CorrelationId = true;
messagePropertyFilter.Body = true;
messagePropertyFilter.Label = true;
messagePropertyFilter.SentTime = true;
messagePropertyFilter.AppSpecific = true;
messageQueue.MessageReadPropertyFilter = messagePropertyFilter;
}
MessageQueue CreateMessageQueue(string path, bool createIfNotExists)
{
var messageQueue = GetMessageQueue(path, createIfNotExists);
messageQueue.Formatter = new RebusTransportMessageFormatter();
var messageReadPropertyFilter = new MessagePropertyFilter();
messageReadPropertyFilter.Id = true;
messageReadPropertyFilter.Body = true;
messageReadPropertyFilter.Extension = true;
messageReadPropertyFilter.Label = true;
messageQueue.MessageReadPropertyFilter = messageReadPropertyFilter;
return(messageQueue);
}
MessageQueue GetMessageQueue(string path)
{
var queue = new MessageQueue(path);
var messageQueue = queue;
messageQueue.Formatter = new RebusTransportMessageFormatter();
var messageReadPropertyFilter = new MessagePropertyFilter();
messageReadPropertyFilter.Id = true;
messageReadPropertyFilter.Body = true;
messageReadPropertyFilter.Extension = true;
messageReadPropertyFilter.Label = true;
messageQueue.MessageReadPropertyFilter = messageReadPropertyFilter;
return(messageQueue);
}
private MessageQueue GetJobResponseQueue()
{
Type[] rTtypes = new Type[] { typeof(FCoordsResult) };
MessagePropertyFilter mpf = new MessagePropertyFilter
{
Body = true,
//Id = true,
CorrelationId = true
};
MessageQueue result = MqHelper.GetQ(INPUT_COORDS_Q_PATH, QueueAccessMode.Receive, rTtypes, mpf);
return(result);
}
private MessageQueue GetJobResponseQueue()
{
Type[] rTtypes = new Type[] { typeof(FJobResult) };
MessagePropertyFilter mpf = new MessagePropertyFilter
{
Body = true,
//Id = true,
CorrelationId = true
};
MessageQueue result = MqHelper.GetQ(_inputQueuePath, QueueAccessMode.Receive, rTtypes, mpf);
return(result);
}
public override void Main(string[] args)
{
_mq = new MessageQueue(@".\private$\my_queue", QueueAccessMode.Receive);
_mq.ReceiveCompleted += new ReceiveCompletedEventHandler(_mq_ReceiveCompleted);
_mq.Formatter = new ActiveXMessageFormatter();
MessagePropertyFilter filter = new MessagePropertyFilter();
filter.Label = true;
filter.Body = true;
filter.AppSpecific = true;
_mq.MessageReadPropertyFilter = filter;
this.DoReceive();
Console.ReadLine();
_mq.Close();
}
public static MessageQueue GetOrCreateMessageQueue(string name)
{
CheckedQueues.GetOrAdd(name, n =>
{
MsmqUtilities.CreateQueueIfNecessary(name);
return(null);
});
var q = new MessageQueue(MsmqUtilities.GetFullPath(name), false, true);
var filter = new MessagePropertyFilter();
filter.SetAll();
q.MessageReadPropertyFilter = filter;
return(q);
}
public void Send(Message message, string destination)
{
destination = ".\\Private$\\" + destination;
// create connection to destination queue
MessageQueue destinationQueue = new MessageQueue(destination);
// Set properties filter
MessagePropertyFilter messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.SetAll();
destinationQueue.MessageReadPropertyFilter = messagePropertyFilter;
// send message to destination
destinationQueue.Send(message, GetTransactionTypeForSend());
}
public void Connect()
{
Disconnect();
_log.DebugFormat("Creating MessageQueue: " + _formatName);
_queue = new MessageQueue(_formatName, _accessMode);
if (_multicastAddress != null)
{
_queue.MulticastAddress = _multicastAddress;
}
var filter = new MessagePropertyFilter();
filter.SetAll();
_queue.MessageReadPropertyFilter = filter;
}
public void mqSendToPoisonQueue(object message, MessagePriority priority)
{
try
{
if (message != null)
{
if (MessageQueue.Exists(_poisonQueueName))
{
using (MessageQueue q = new MessageQueue(_poisonQueueName))
{
q.DefaultPropertiesToSend.Recoverable = true;
MessagePropertyFilter mf = new MessagePropertyFilter();
mf.SetAll();
mf.AppSpecific = true;
q.MessageReadPropertyFilter = mf;
if (message is UpdateMessage updmsg)
{
var msg = new Message(updmsg)
{
Priority = priority
};
q.Send(msg, updmsg.ToString());
}
else
{
var msg = new Message(message)
{
Priority = priority
};
q.Send(msg, message.ToString());
}
}
}
else
{
Logger.Error(new Exception("StarChef Message Queue: " + _poisonQueueName + " does not exist. Please check MSMQ Setup"));
}
}
}
catch (Exception ex)
{
Logger.Error("StarChef: MSMQ Errored while adding a message to the Poison Queue.", ex);
}
}
/// <summary>
/// Sets the queue on the transport to the specified MSMQ queue.
/// </summary>
/// <param name="q">The MSMQ queue to set.</param>
protected void SetLocalQueue(MessageQueue q)
{
//q.MachineName = Environment.MachineName; // just in case we were given "localhost"
if (!q.Transactional)
{
throw new ArgumentException("Queue must be transactional (" + q.Path + ").");
}
else
{
LocalQueue = q;
}
MessagePropertyFilter mpf = new MessagePropertyFilter();
mpf.SetAll();
LocalQueue.MessageReadPropertyFilter = mpf;
}
public void LocalInitialize(bool isTransactional, IMessageSerializer messageSerializer, String channelInfo
, string failoverQueueName, int failoverRetryInterval, int failoverWaitInterval)
{
base.IsTransactional = isTransactional;
base.MessageSerializer = messageSerializer;
ChannelInfo = channelInfo;
FailoverQueueName = failoverQueueName;
FailoverRetryInterval = failoverRetryInterval;
FailoverWaitInterval = failoverWaitInterval;
_failoverQueue = new MessageQueue(FailoverQueueName);
MessagePropertyFilter messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.SetAll();
_failoverQueue.MessageReadPropertyFilter = messagePropertyFilter;
}
