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;
}
void IMessageTransport.Init(Address address)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
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()));
}
var fullPath = MsmqUtilities.GetFullPathWithoutPrefix(address);
if (MessageQueue.Exists(fullPath))
{
_messageQueue = new MessageQueue(fullPath);
}
else
{
_messageQueue = MessageQueue.Create(fullPath);
}
var mpf = new MessagePropertyFilter();
mpf.SetAll();
_messageQueue.MessageReadPropertyFilter = mpf;
if (PurgeOnStartup)
{
_messageQueue.Purge();
}
}
public static MessageQueue GetOrCreateMessageQueue(string name)
{
MsmqUtilities.CreateQueueIfNecessary(name);
var q = new MessageQueue(MsmqUtilities.GetFullPath(name));
var filter = new MessagePropertyFilter();
filter.SetAll();
q.MessageReadPropertyFilter = filter;
return q;
}
public Consumer(string channelName)
{
// Attach to a message queue identified in channelName and set the formatter
channel = new MessageQueue(channelName) {Formatter = new XmlMessageFormatter(new[] {typeof(string)})};
// We want to trace message headers such as correlation id, so we need to tell MSMQ to retrieve those by setting the property filter
MessagePropertyFilter filter = new MessagePropertyFilter();
filter.SetAll();
channel.MessageReadPropertyFilter = filter;
}
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 Consumer(string channelName)
{
// Attach to a message queue and set the formatter so we can read the messages
channel = new MessageQueue(channelName) {Formatter = new XmlMessageFormatter(new[] {typeof(string)})};
// We want to trace message headers such as correlation id, so we need to tell MSMQ to retrieve those
MessagePropertyFilter filter = new MessagePropertyFilter();
filter.SetAll();
channel.MessageReadPropertyFilter = filter;
//we use a timer to poll the queue at a regular interval, of course this may need to be re-entrant but we have no state to worry about
timer = new Timer(ConfigurationSettings.PollingInterval) {AutoReset = true};
// on the Timer's Elapsed event we want to consume messages, so set the callback to our Consume method
timer.Elapsed += timer_Elapsed;
}
protected override void ProcessRecord()
{
var queueAddress = string.Format("FormatName:DIRECT=OS:{0}\\private$\\{1}", Environment.MachineName,QueueName);
var queue = new MessageQueue(queueAddress);
var mpf = new MessagePropertyFilter();
mpf.SetAll();
queue.MessageReadPropertyFilter = mpf;
var output = queue.GetAllMessages().Select(m => new
{
m.Id,
Headers = ParseHeaders(m),
m.ArrivedTime
});
WriteObject(output, true);
}
public static void Pick_From_NServiceBus_Msmq()
{
var address = Address.Parse("*****@*****.**");
address = Address.Parse("MessageMonitorAudit");
var path = NServiceBus.Utils.MsmqUtilities.GetFullPath(address);
using (var queue = new MessageQueue(path, QueueAccessMode.PeekAndAdmin))
{
var mpf = new MessagePropertyFilter();
mpf.SetAll();
queue.MessageReadPropertyFilter = mpf;
var msg = queue.Peek(TimeSpan.FromMinutes(1));
var tm = NServiceBus.Utils.MsmqUtilities.Convert(msg);
if(tm.Is_Failed_Message())
tm.To_NServiceBus_Failed_Message();
}
}
public MsmqQueue(Uri uri, IMsmqConfiguration configuration)
{
Guard.AgainstNull(uri, "uri");
Guard.AgainstNull(configuration, "configuration");
_log = Log.For(this);
_parser = new MsmqUriParser(uri);
_timeout = _parser.Local
? TimeSpan.FromMilliseconds(configuration.LocalQueueTimeoutMilliseconds)
: TimeSpan.FromMilliseconds(configuration.RemoteQueueTimeoutMilliseconds);
Uri = _parser.Uri;
_messagePropertyFilter = new MessagePropertyFilter();
_messagePropertyFilter.SetAll();
_dequeuePipelinePool = new ReusableObjectPool<MsmqGetMessagePipeline>();
}
public void Instrument()
{
foreach (var serviceInfo in Services)
{
var address = new Address(serviceInfo.ErrorQueue, MachineName);
var queue = new MessageQueue(MsmqUtilities.GetFullPath(address));
var filter = new MessagePropertyFilter();
filter.SetAll();
queue.MessageReadPropertyFilter = filter;
var messages = queue.GetAllMessages();
foreach (var message in messages)
{
var transportMessage = MsmqUtilities.Convert(message);
if (transportMessage.Headers.ContainsKey(Faults.FaultsHeaderKeys.FailedQ))
{
var value = Address.Parse(transportMessage.Headers[Faults.FaultsHeaderKeys.FailedQ]);
if (serviceInfo.Name.Equals(value.Queue, StringComparison.InvariantCultureIgnoreCase))
{
var messageText = Encoding.UTF8.GetString(transportMessage.Body);
using (var con = GetConnection())
{
const string sql = "INSERT INTO Error (ErrorId, ServiceName, MachineName, Message, ErrorMessage, Stacktrace, MessageSentTimeUtc) VALUES(@errorId, @serviceName, @machineName, @message, @errorMessage, @stacktrace, @messageSentTimeUtc)";
var errorMessage = transportMessage.Headers["NServiceBus.ExceptionInfo.Message"];
var stackTrace = transportMessage.Headers["NServiceBus.ExceptionInfo.StackTrace"];
var messageSentTimeUtc = transportMessage.Headers["NServiceBus.TimeOfFailure"].ToUtcDateTime();
con.Execute(sql, new { ErrorId = Guid.NewGuid(), serviceName = serviceInfo.Name, MachineName, message = messageText, errorMessage, stackTrace, messageSentTimeUtc });
}
}
}
}
}
}
//public void Start_Monitoring_Queue(string queueName)
//{
// Start_Monitoring_Queue(Address.Parse(queueName));
//}
public void Start_Monitoring_Queue(string queueName)
{
//var path = NServiceBus.Utils.MsmqUtilities.GetFullPath(queueName);
var queue = new MessageQueue(queueName, QueueAccessMode.PeekAndAdmin);
var mpf = new System.Messaging.MessagePropertyFilter();
mpf.SetAll();
queue.MessageReadPropertyFilter = mpf;
queue.PeekCompleted += queue_PeekCompleted;
if(!Queues_To_Monitor.Contains(queueName))
Queues_To_Monitor.Add(queueName);
}
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();
}
public NServiceBus_MSMQ_Audit_Queue_Listener(IBus bus, Address queueName)
{
Bus = bus;
var path = NServiceBus.Utils.MsmqUtilities.GetFullPath(queueName);
Queue = new MessageQueue(path, QueueAccessMode.ReceiveAndAdmin);
var mpf = new MessagePropertyFilter();
mpf.SetAll();
Queue.MessageReadPropertyFilter = mpf;
Queue.PeekCompleted += queue_PeekCompleted;
}
private static MessageQueue InitalizeQueue(Uri endpoint)
{
try
{
var messageQueue = endpoint.CreateQueue(QueueAccessMode.SendAndReceive);
var filter = new MessagePropertyFilter();
filter.SetAll();
messageQueue.MessageReadPropertyFilter = filter;
return messageQueue;
}
catch (Exception e)
{
throw new TransportException(
"Could not open queue: " + endpoint + Environment.NewLine +
"Queue path: " + MsmqUtil.GetQueuePath(endpoint), e);
}
}
/// <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;
endpointAddress = address;
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 mpf = new MessagePropertyFilter();
mpf.SetAll();
queue.MessageReadPropertyFilter = mpf;
if (PurgeOnStartup)
{
queue.Purge();
}
}
private void Reconnect()
{
if (_queue != null)
{
_queue.Dispose();
_queue = null;
}
_queue = new MessageQueue(_formatName, _accessMode);
if (_multicastAddress != null)
{
_queue.MulticastAddress = _multicastAddress;
}
var filter = new MessagePropertyFilter();
filter.SetAll();
_queue.MessageReadPropertyFilter = filter;
_needReconnect = false;
}
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);
}
public void Init(string address, bool transactional)
{
useTransactions = transactional;
if (string.IsNullOrEmpty(address))
throw new ArgumentException("Input queue must be specified");
var machine = MsmqUtilities.GetMachineNameFromLogicalName(address);
if (machine.ToLower() != Environment.MachineName.ToLower())
throw new InvalidOperationException("Input queue must be on the same machine as this process.");
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();
}
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;
}
private MessageQueue CreateGuardedQueue()
{
var messageQueue = new MessageQueue(path);
var messagePropertyFilter = new MessagePropertyFilter();
messagePropertyFilter.SetAll();
messageQueue.MessageReadPropertyFilter = messagePropertyFilter;
return messageQueue;
}
void ISubscriptionStorage.Init()
{
string path = MsmqUtilities.GetFullPath(Queue);
q = new MessageQueue(path);
bool transactional;
try
{
transactional = q.Transactional;
}
catch (Exception ex)
{
throw new ArgumentException(string.Format("There is a problem with the subscription storage queue {0}. See enclosed exception for details.", Queue), ex);
}
if (!transactional)
throw new ArgumentException("Queue must be transactional (" + Queue + ").");
var mpf = new MessagePropertyFilter();
mpf.SetAll();
q.Formatter = new XmlMessageFormatter(new[] { typeof(string) });
q.MessageReadPropertyFilter = mpf;
foreach (var m in q.GetAllMessages())
{
var subscriber = Address.Parse(m.Label);
var messageType = m.Body as string;
entries.Add(new Entry { MessageType = messageType, Subscriber = subscriber});
AddToLookup(subscriber, messageType, m.Id);
}
}
