public static IAsbOptions UseAzureServiceBusInOneWayClientMode(this RebusTransportConfigurer configurer,
string connectionString)
{
IAsbOptions asbOptionsToReturn;
if (ShouldEmulateAzureEnvironment(connectionString))
{
var sender = MsmqMessageQueue.Sender();
configurer.UseSender(sender);
asbOptionsToReturn = new NoopAsbOptions();
}
else
{
var sender = AzureServiceBusMessageQueue.Sender(connectionString);
configurer.UseSender(sender);
asbOptionsToReturn = new AsbOptions(sender);
}
var gag = new OneWayClientGag();
configurer.UseReceiver(gag);
configurer.UseErrorTracker(gag);
return(asbOptionsToReturn);
}
public Tuple <ISendMessages, IReceiveMessages> GetQueue(string inputQueueName)
{
var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue();
disposables.Add(messageQueue);
return(new Tuple <ISendMessages, IReceiveMessages>(messageQueue, messageQueue));
}
public void WorksWhenMovingToErrorQueue()
{
using (var messageQueue = new MsmqMessageQueue("error"))
{
// make sure error queue is empty
messageQueue.PurgeInputQueue();
adapter.Handle <Request>(req =>
{
throw new ApplicationException("oh crap");
});
var request = new Request();
bus.AttachHeader(request, Headers.CorrelationId, "super-unique!!!!111");
bus.SendLocal(request);
// let it fail
Thread.Sleep(2.Seconds());
var receivedTransportMessage = messageQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var serializer = new JsonMessageSerializer();
var message = serializer.Deserialize(receivedTransportMessage);
message.Headers.ShouldContainKeyAndValue(Headers.CorrelationId, "super-unique!!!!111");
}
}
static void PurgeInputQueue(string inputQueueName)
{
using (var queue = new MsmqMessageQueue(inputQueueName))
{
queue.PurgeInputQueue();
}
}
public void DoesNotLeakMessages()
{
// arrange
const string inputQueueName = "test.leak.input";
var queue = new MsmqMessageQueue(inputQueueName);
disposables.Add(queue);
var body = Encoding.UTF8.GetBytes(new string('*', 32768));
var message = new TransportMessageToSend
{
Headers = new Dictionary <string, object> {
{ Headers.MessageId, "msg-1" }
},
Body = body
};
var weakMessageRef = new WeakReference(message);
var weakBodyRef = new WeakReference(body);
// act
queue.Send(inputQueueName, message, new NoTransaction());
message = null;
body = null;
GC.Collect();
GC.WaitForPendingFinalizers();
// assert
Assert.That(weakMessageRef.IsAlive, Is.False, "Expected the message to have been collected");
Assert.That(weakBodyRef.IsAlive, Is.False, "Expected the body bytes to have been collected");
}
MsmqMessageQueue GetQueue(string queueName)
{
var queue = new MsmqMessageQueue(queueName).PurgeInputQueue();
disposables.Add(queue);
return(queue);
}
/// <summary>
/// Dispose pattern.
/// </summary>
/// <param name="isDisposing">Invoked from Dispose().</param>
protected virtual void Dispose(bool isDisposing)
{
if (_queue != null)
{
_queue.Dispose();
_queue = null;
}
}
public LoadBalancerWorker(MsmqMessageQueue queue, int workerNumber, Func <string> getNextDestination)
{
this.queue = queue;
this.workerNumber = workerNumber;
this.getNextDestination = getNextDestination;
workerThread = new Thread(DoWork);
log.Info("Starting load balancer worker {0}", workerNumber);
workerThread.Start();
}
void StartWorker()
{
using (var messageQueue = new MsmqMessageQueue(listenQueue))
{
while (keepRunning)
{
DoWork(messageQueue);
}
}
}
public void SendMsmqMessageToUnknownRemoteQueue()
{
var sender = MsmqMessageQueue.Sender();
sender.Send("nonexistingQueue@DACAPPL03", new TransportMessageToSend
{
Label = "unknown host",
Headers = new Dictionary <string, object>(),
Body = Encoding.UTF8.GetBytes("muahahahahahahaha"),
}, new NoTransaction());
}
public AnalyticsRepository(AnalysisDbContext dbContext, ConfigurationStore configurationStore)
{
_unitOfWork = dbContext?.UnitOfWork ?? throw new ArgumentNullException(nameof(dbContext));
var settings = configurationStore.Load <MessageQueueSettings>();
if (settings != null && !settings.UseSql)
{
_queue = new MsmqMessageQueue(settings.ReportQueue, settings.ReportAuthentication,
settings.ReportTransactions);
}
}
protected override void DoSetUp()
{
serializer = new JsonMessageSerializer();
senderQueue = new MsmqMessageQueue(SenderQueueName);
destinationQueue = NewRawMsmqQueue(DestinationQueueName);
senderQueue.PurgeInputQueue();
destinationQueue.Purge();
TrackDisposable(senderQueue);
}
static List <ReceivedTransportMessage> GetAllTheMessages(MsmqMessageQueue msmqMessageQueue, ITransactionContext transactionContext)
{
var messages = new List <ReceivedTransportMessage>();
ReceivedTransportMessage transportMessage;
while ((transportMessage = msmqMessageQueue.ReceiveMessage(transactionContext)) != null)
{
messages.Add(transportMessage);
}
return(messages);
}
public AnalyticsRepository(IAdoNetUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
var settings = ConfigurationStore.Instance.Load <MessageQueueSettings>();
if (settings != null && !settings.UseSql)
{
_queue = new MsmqMessageQueue(settings.ReportQueue, settings.ReportAuthentication,
settings.ReportTransactions);
}
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName)
{
var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue();
MsmqUtil.PurgeQueue(errorQueueName);
serializer = new JsonMessageSerializer();
var bus = new RebusBus(activateHandlers, messageQueue, messageQueue,
storeSubscriptions, storeSagaData,
this, serializer, pipelineInspector,
new ErrorTracker(errorQueueName));
EnsureProperDisposal(bus);
EnsureProperDisposal(messageQueue);
return(bus);
}
public void SetUp()
{
disposables = new List <IDisposable>();
serializer = new JsonMessageSerializer();
senderQueue = new MsmqMessageQueue("test.msmq.tx.sender");
destinationQueueName = "test.msmq.tx.destination";
destinationQueue = NewRawMsmqQueue(destinationQueueName);
senderQueue.PurgeInputQueue();
destinationQueue.Purge();
disposables.Add(senderQueue);
disposables.Add(destinationQueue);
}
public LoadBalancerService Start()
{
if (!destinationQueueNames.Any())
{
throw new InvalidOperationException("Cannot start load balancer without adding at least one worker input queue!");
}
log.Info("Starting load balancer");
queue = new MsmqMessageQueue(inputQueueName);
workers.AddRange(Enumerable.Range(1, numberOfWorkers)
.Select(i => new LoadBalancerWorker(queue, i, GetNextDestination)));
return(this);
}
private string SendMessageImpl(object message, string correlationId, TimeSpan timeToBeReceived)
{
var transactionOptions = new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
};
var transactionScope = !IsTransactional
? null
: new TransactionScope(TransactionScopeOption.Required, transactionOptions);
using (transactionScope)
{
try
{
var msg = new Message {
Body = message, TimeToBeReceived = timeToBeReceived
};
if (!string.IsNullOrEmpty(correlationId))
{
msg.CorrelationId = correlationId;
}
MsmqMessageQueue.Send(
msg,
IsTransactional ? MessageQueueTransactionType.Automatic : MessageQueueTransactionType.None);
lock (Synch)
{
AddMessageAudit(msg);
}
Logger.DebugFormat("Sent message to [{0}]...", QueueName);
if (transactionScope != null)
{
transactionScope.Complete();
}
return(msg.Id);
}
catch (Exception ex)
{
Logger.ErrorFormat(ex, "Exception encountered by [{0}] sending Message [{1}].", this, message);
throw;
}
}
}
public static void UseAzureServiceBusInOneWayClientMode(this RebusTransportConfigurer configurer,
string connectionString)
{
if (ShouldEmulateAzureEnvironment(connectionString))
{
var sender = MsmqMessageQueue.Sender();
configurer.UseSender(sender);
}
else
{
var sender = AzureServiceBusMessageQueue.Sender(connectionString);
configurer.UseSender(sender);
}
var gag = new OneWayClientGag();
configurer.UseReceiver(gag);
configurer.UseErrorTracker(gag);
}
protected override void DoSetUp()
{
DropCollection("sagas");
var msmqMessageQueue = new MsmqMessageQueue("test.dispatcher.and.mongo");
handlers = new HandlerActivatorForTesting().UseHandler(new MySaga());
var persister = new MongoDbSagaPersister(ConnectionString)
.SetCollectionName <MySagaData>("sagas");
bus = new RebusBus(handlers, msmqMessageQueue,
msmqMessageQueue, new InMemorySubscriptionStorage(),
persister,
null,
new JsonMessageSerializer(),
new TrivialPipelineInspector(),
new ErrorTracker("error"))
.Start(1);
}
public void CheckSendPerformance(int count)
{
var queue = new MsmqMessageQueue("test.msmq.performance").PurgeInputQueue();
TrackDisposable(queue);
var transportMessageToSend = new TransportMessageToSend
{
Headers = new Dictionary <string, object>(),
Body = new byte[1024],
Label = "this is just a label"
};
var stopwatch = Stopwatch.StartNew();
count.Times(() => queue.Send("test.msmq.performance", transportMessageToSend, new NoTransaction()));
var totalSeconds = stopwatch.Elapsed.TotalSeconds;
Console.WriteLine("Sending {0} messages took {1:0} s - that's {2:0} msg/s",
count, totalSeconds, count / totalSeconds);
}
public void CanSendAndReceiveMessageToQueueOnLocalhost()
{
// arrange
var queue = new MsmqMessageQueue("test.msmq.loca.input").PurgeInputQueue();
TrackDisposable(queue);
const string localHostQualifiedQueueName = "test.msmq.loca.input@localhost";
// act
queue.Send(localHostQualifiedQueueName, new TransportMessageToSend {
Body = Encoding.UTF8.GetBytes("yo dawg!")
}, new NoTransaction());
Thread.Sleep(200);
// assert
var receivedTransportMessage = queue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
Encoding.UTF8.GetString(receivedTransportMessage.Body).ShouldBe("yo dawg!");
}
public void CanSendAndReceiveMessageToQueueOnSpecificMachine()
{
// arrange
var queue = new MsmqMessageQueue("test.msmq.mach.input").PurgeInputQueue();
TrackDisposable(queue);
var machineQualifiedQueueName = "test.msmq.mach.input@" + Environment.MachineName;
// act
queue.Send(machineQualifiedQueueName, new TransportMessageToSend {
Body = Encoding.UTF8.GetBytes("yo dawg!")
}, new NoTransaction());
Thread.Sleep(200);
// assert
var receivedTransportMessage = queue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
Encoding.UTF8.GetString(receivedTransportMessage.Body).ShouldBe("yo dawg!");
}
public void Setup()
{
if (MessageQueue.Exists(queueId))
{
MessageQueue.Delete(queueId);
}
//var acl = new System.Messaging.AccessControlList {
// new System.Messaging.AccessControlEntry(
// new System.Messaging.Trustee(Environment.UserName, Environment.MachineName),
// System.Messaging.GenericAccessRights.All,
// System.Messaging.StandardAccessRights.All,
// System.Messaging.AccessControlEntryType.Allow)
//};
_sut = new MsmqMessageQueue(new QueueCreationOptions {
QueueId = queueId,
QueueName = "AnyQ.Queues.Msmq Test Queue"
}, false);
_backingQueue = new MessageQueue(queueId);
}
void HandlePost(HttpListenerResponse response, HttpListenerRequest request)
{
using (var reader = new BinaryReader(request.InputStream))
{
var receivedTransportMessage = new ReceivedTransportMessage
{
Id = request.Headers[RebusHttpHeaders.Id],
Body = reader.ReadBytes((int)request.ContentLength64)
};
var headers = new Dictionary <string, string>();
foreach (var rebusHeaderKey in request.Headers.AllKeys.Where(k => k.StartsWith(RebusHttpHeaders.CustomHeaderPrefix)))
{
var value = request.Headers[rebusHeaderKey];
var key = rebusHeaderKey.Substring(RebusHttpHeaders.CustomHeaderPrefix.Length);
headers.Add(key, value);
}
log.Info("Got headers in request: {0}", string.Join(", ", headers.Keys));
receivedTransportMessage.Headers = headers;
log.Info("Received message {0}", receivedTransportMessage.Id);
using (var queue = MsmqMessageQueue.Sender())
{
queue.Send(destinationQueue, receivedTransportMessage.ToForwardableMessage());
}
log.Info("Message was sent to {0}", destinationQueue);
response.StatusCode = (int)HttpStatusCode.OK;
response.Close();
}
}
public void CanSendAndReceiveMessageToQueueOnMachineSpecifiedByIp()
{
var ipAddress = GuessOwnIpAddress();
// arrange
var queue = new MsmqMessageQueue("test.msmq.ip.input").PurgeInputQueue();
TrackDisposable(queue);
var ipQualifiedName = "test.msmq.ip.input@" + ipAddress;
// act
queue.Send(ipQualifiedName, new TransportMessageToSend {
Body = Encoding.UTF8.GetBytes("yo dawg!")
}, new NoTransaction());
Thread.Sleep(1.Seconds());
// assert
var receivedTransportMessage = queue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
Encoding.UTF8.GetString(receivedTransportMessage.Body).ShouldBe("yo dawg!");
}
public TimeoutService(IStoreTimeouts storeTimeouts, string inputQueueName, string errorQueueName)
{
var msmqMessageQueue = new MsmqMessageQueue(inputQueueName);
Initialize(storeTimeouts, msmqMessageQueue, msmqMessageQueue, errorQueueName);
}
public TimeoutService(IStoreTimeouts storeTimeouts)
{
var msmqMessageQueue = new MsmqMessageQueue(DefaultInputQueueName);
Initialize(storeTimeouts, msmqMessageQueue, msmqMessageQueue, DefaultErrorQueueName);
}
static void Run(Parameters parameters)
{
if (string.IsNullOrWhiteSpace(parameters.ErrorQueueName))
{
throw new NiceException("Please specify the name of an error queue");
}
using (var tx = new TransactionScope())
{
var transactionContext = new AmbientTransactionContext();
if (!MessageQueue.Exists(MsmqUtil.GetPath(parameters.ErrorQueueName)))
{
throw new NiceException("The MSMQ queue '{0}' does not exist!", parameters.ErrorQueueName);
}
var msmqMessageQueue = new MsmqMessageQueue(parameters.ErrorQueueName, allowRemoteQueue: true);
var allTheMessages = GetAllTheMessages(msmqMessageQueue, transactionContext);
foreach (var message in allTheMessages)
{
var transportMessageToSend = message.ToForwardableMessage();
try
{
if (!transportMessageToSend.Headers.ContainsKey(Headers.SourceQueue))
{
throw new NiceException(
"Message {0} does not have a source queue header - it will be moved back to the input queue",
message.Id);
}
var sourceQueue = (string)transportMessageToSend.Headers[Headers.SourceQueue];
if (parameters.AutoMoveAllMessages.GetValueOrDefault())
{
msmqMessageQueue.Send(sourceQueue, transportMessageToSend, transactionContext);
Print("Moved {0} to {1}", message.Id, sourceQueue);
}
else
{
var answer = PromptChar(new[] { 'y', 'n' }, "Would you like to move {0} to {1}? (y/n)",
message.Id, sourceQueue);
if (answer == 'y')
{
msmqMessageQueue.Send(sourceQueue, transportMessageToSend, transactionContext);
Print("Moved {0} to {1}", message.Id, sourceQueue);
}
else
{
msmqMessageQueue.Send(msmqMessageQueue.InputQueueAddress,
transportMessageToSend,
transactionContext);
Print("Moved {0} to {1}", message.Id, msmqMessageQueue.InputQueueAddress);
}
}
}
catch (NiceException e)
{
Print(e.Message);
msmqMessageQueue.Send(msmqMessageQueue.InputQueueAddress,
transportMessageToSend,
transactionContext);
}
}
if (parameters.DryRun.GetValueOrDefault())
{
Print("Aborting queue transaction");
return;
}
if (!parameters.Interactive)
{
tx.Complete();
return;
}
var commitAnswer = PromptChar(new[] { 'y', 'n' }, "Would you like to commit the queue transaction?");
if (commitAnswer == 'y')
{
Print("Committing queue transaction");
tx.Complete();
return;
}
Print("Queue transaction aborted");
}
}
