public MsmqAddress MakeCompatibleWith(MsmqAddress other, Func<string, string> ipLookup)
{
IPAddress _;
if (IPAddress.TryParse(other.Machine, out _) && !IPAddress.TryParse(Machine, out _))
{
return new MsmqAddress(Queue, ipLookup(Machine));
}
return this;
}
public WorkerFeature()
{
DependsOn<DelayedDeliveryFeature>();
Defaults(s =>
{
var distributorAddress = s.Get<string>("LegacyDistributor.Address");
var distributorMsmqAddress = MsmqAddress.Parse(distributorAddress);
var distributorTimeoutQueue = new MsmqAddress(distributorMsmqAddress.Queue + ".Timeouts", distributorMsmqAddress.Machine);
var timeoutManagerAddressConfiguration = s.Get<TimeoutManagerAddressConfiguration>();
timeoutManagerAddressConfiguration.Set(distributorTimeoutQueue.ToString());
});
}
void CreateQueueIfNecessary(string address, string identity)
{
var msmqAddress = MsmqAddress.Parse(address);
Logger.Debug($"Creating '{address}' if needed.");
if (msmqAddress.IsRemote)
{
Logger.Info($"'{address}' is a remote queue and won't be created");
return;
}
var queuePath = msmqAddress.PathWithoutPrefix;
if (MessageQueue.Exists(queuePath))
{
Logger.Debug($"'{address}' already exists");
return;
}
try
{
using (var queue = MessageQueue.Create(queuePath, useTransactionalQueues))
{
Logger.Debug($"Created queue, path: [{queuePath}], identity: [{identity}], transactional: [{useTransactionalQueues}]");
try
{
queue.SetPermissions(identity, MessageQueueAccessRights.WriteMessage);
queue.SetPermissions(identity, MessageQueueAccessRights.ReceiveMessage);
queue.SetPermissions(identity, MessageQueueAccessRights.PeekMessage);
queue.SetPermissions(LocalAdministratorsGroupName, MessageQueueAccessRights.FullControl);
}
catch (MessageQueueException permissionException) when(permissionException.MessageQueueErrorCode == MessageQueueErrorCode.FormatNameBufferTooSmall)
{
Logger.Warn($"The name for queue '{queue.FormatName}' is too long for permissions to be applied. Please consider a shorter endpoint name.", permissionException);
}
}
}
catch (MessageQueueException ex) when(ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueExists)
{
//Solves the race condition problem when multiple endpoints try to create same queue (e.g. error queue).
}
}
public MsmqSubscriptionStorageQueue(MsmqAddress queueAddress)
{
q = new MessageQueue(queueAddress.FullPath);
var messageReadPropertyFilter = new MessagePropertyFilter
{
Id = true,
Body = true,
Label = true,
ArrivedTime = true
};
q.Formatter = new XmlMessageFormatter(new[]
{
typeof(string)
});
q.MessageReadPropertyFilter = messageReadPropertyFilter;
}
public MsmqSubscriptionStorageQueue(MsmqAddress queueAddress, bool useTransactionalQueue)
{
transactionTypeToUseForSend = useTransactionalQueue ? MessageQueueTransactionType.Single : MessageQueueTransactionType.None;
queue = new MessageQueue(queueAddress.FullPath);
var messageReadPropertyFilter = new MessagePropertyFilter
{
Id = true,
Body = true,
Label = true,
ArrivedTime = true
};
queue.Formatter = new XmlMessageFormatter(new[]
{
typeof(string)
});
queue.MessageReadPropertyFilter = messageReadPropertyFilter;
}
public MsmqSubscriptionStorageQueue(MsmqAddress queueAddress, bool useTransactionalQueue)
{
transactionTypeToUseForSend = useTransactionalQueue ? MessageQueueTransactionType.Single : MessageQueueTransactionType.None;
queue = new MessageQueue(queueAddress.FullPath);
var messageReadPropertyFilter = new MessagePropertyFilter
{
Id = true,
Body = true,
Label = true,
ArrivedTime = true
};
queue.Formatter = new XmlMessageFormatter(new[]
{
typeof(string)
});
queue.MessageReadPropertyFilter = messageReadPropertyFilter;
}
public static bool TryOpenQueue(MsmqAddress msmqAddress, out MessageQueue messageQueue)
{
messageQueue = null;
var queuePath = msmqAddress.PathWithoutPrefix;
Logger.Debug($"Checking if queue exists: {queuePath}.");
if (msmqAddress.IsRemote)
{
Logger.Debug("Queue is on remote machine.");
Logger.Debug("If this does not succeed (like if the remote machine is disconnected), processing will continue.");
}
var path = msmqAddress.PathWithoutPrefix;
try
{
if (MessageQueue.Exists(path))
{
messageQueue = new MessageQueue(path);
Logger.DebugFormat("Verified that the queue: [{0}] existed", queuePath);
return(true);
}
}
catch (MessageQueueException)
{
// Can happen because of an invalid queue path or trying to access a remote private queue.
// Either way, this results in a failed attempt, therefore returning false.
return(false);
}
return(false);
}
public override string MakeCanonicalForm(string transportAddress)
{
return(MsmqAddress.Parse(transportAddress).ToString());
}
void ExecuteTransportOperation(TransportTransaction transaction, UnicastTransportOperation transportOperation)
{
var message = transportOperation.Message;
var destination = transportOperation.Destination;
var destinationAddress = MsmqAddress.Parse(destination);
if (IsCombiningTimeToBeReceivedWithTransactions(
transaction,
transportOperation.RequiredDispatchConsistency,
transportOperation.DeliveryConstraints))
{
throw new Exception($"Failed to send message to address: {destinationAddress.Queue}@{destinationAddress.Machine}. Sending messages with a custom TimeToBeReceived is not supported on transactional MSMQ.");
}
try
{
using (var q = new MessageQueue(destinationAddress.FullPath, false, settings.UseConnectionCache, QueueAccessMode.Send))
{
using (var toSend = MsmqUtilities.Convert(message, transportOperation.DeliveryConstraints))
{
toSend.UseDeadLetterQueue = settings.UseDeadLetterQueue;
toSend.UseJournalQueue = settings.UseJournalQueue;
toSend.TimeToReachQueue = settings.TimeToReachQueue;
string replyToAddress;
if (message.Headers.TryGetValue(Headers.ReplyToAddress, out replyToAddress))
{
toSend.ResponseQueue = new MessageQueue(MsmqAddress.Parse(replyToAddress).FullPath);
}
var label = GetLabel(message);
if (transportOperation.RequiredDispatchConsistency == DispatchConsistency.Isolated)
{
q.Send(toSend, label, GetIsolatedTransactionType());
return;
}
MessageQueueTransaction activeTransaction;
if (TryGetNativeTransaction(transaction, out activeTransaction))
{
q.Send(toSend, label, activeTransaction);
return;
}
q.Send(toSend, label, GetTransactionTypeForSend());
}
}
}
catch (MessageQueueException ex)
{
if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound)
{
var msg = destination == null
? "Failed to send message. Target address is null."
: $"Failed to send message to address: [{destination}]";
throw new QueueNotFoundException(destination, msg, ex);
}
ThrowFailedToSendException(destination, ex);
}
catch (Exception ex)
{
ThrowFailedToSendException(destination, ex);
}
}