void DoWork(IReceiveMessages messageQueue) { try { using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); var receivedTransportMessage = messageQueue.ReceiveMessage(ctx); if (receivedTransportMessage == null) return; try { SendMessage(receivedTransportMessage); tx.Complete(); } catch (Exception e) { log.Error(e, "Could not send message {0} to destination URI {1} - waiting 1 sec before retrying", receivedTransportMessage.Id, destinationUri); Thread.Sleep(TimeSpan.FromSeconds(1)); } } } catch (Exception e) { log.Error("Unhandled exception during receive operation", e); } }
public void CleanupIsPerformedEvenIfTransactionIsNotCommitted() { int cleanupCalled = 0; var tx = new TransactionScope(); var ctx = new AmbientTransactionContext(); ctx.Cleanup += () => { cleanupCalled++; }; tx.Dispose(); cleanupCalled.ShouldBe(1); }
public void CleanupIsPerformedOnDispose() { bool cleanupCalled = false; var tx = new TransactionScope(); var ctx = new AmbientTransactionContext(); ctx.Cleanup += () => { cleanupCalled = true; }; tx.Dispose(); cleanupCalled.ShouldBe(true); }
public void CleanupIsPerformedOnce() { int cleanupCalled = 0; var tx = new TransactionScope(); var ctx = new AmbientTransactionContext(); ctx.Cleanup += () => { cleanupCalled++; }; tx.Complete(); cleanupCalled.ShouldBe(0); tx.Dispose(); cleanupCalled.ShouldBe(1); }
public void DoesNotLeakConnectionsForEachMessage() { // Low timeout + pool size will quickly show the issue. var cs = ConnectionString + ";Connect Timeout = 5;Max Pool Size=10"; var transport = new SqlServerMessageQueue(cs, TableName, InputQueueName); transport.EnsureTableIsCreated(); transport.PurgeInputQueue(); for (int i = 0; i < 100; i++) { using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); transport.Send(InputQueueName, new TransportMessageToSend() { Body = new byte[0], Headers = new Dictionary<string, object>(), Label = "test" }, ctx); tx.Complete(); } } }
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 (!AzureServiceBusErrorQueueExists(parameters)) { throw new NiceException("The Azure Service Bus queue '{0}' does not exist!", parameters.ErrorQueueName); } var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(parameters.ConnectionString, parameters.ErrorQueueName); var allTheMessages = GetAllTheMessages(azureServiceBusMessageQueue, 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()) { azureServiceBusMessageQueue.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') { azureServiceBusMessageQueue.Send(sourceQueue, transportMessageToSend, transactionContext); Print("Moved {0} to {1}", message.Id, sourceQueue); } else { azureServiceBusMessageQueue.Send(azureServiceBusMessageQueue.InputQueueAddress, transportMessageToSend, transactionContext); Print("Moved {0} to {1}", message.Id, azureServiceBusMessageQueue.InputQueueAddress); } } } catch (NiceException e) { Print(e.Message); azureServiceBusMessageQueue.Send(azureServiceBusMessageQueue.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"); } }
public void CanSendMessagesDirectlyToExchangeWithRoutingKey(int mode) { // arrange var routeUsingExchanges = mode > 1; var exchangeAsAddress = mode > 2; var sender = GetQueue("test.sender", removeExiting: true, oneExchangePerType: routeUsingExchanges, inputExchange: exchangeAsAddress ? "ex-test.sender" : null); var recipient = GetQueue("test.recipient", removeExiting: true); using (var cm = new ConnectionManager(ConnectionString, "test.sender")) using (var conn = cm.GetConnection()) using (var model = conn.CreateModel()) { model.QueueBind("test.recipient", "ex-test.recipient", "sample"); } // act using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); var msg = new TransportMessageToSend { Body = Encoding.GetBytes("this is a message!") }; sender.Send("*****@*****.**", msg, ctx); sender.Send("*****@*****.**", msg, ctx); sender.Send("*****@*****.**", msg, ctx); tx.Complete(); } // assert var receivedTransportMessages = GetAllMessages(recipient); receivedTransportMessages.Count.ShouldBe(3); }
public void CanSendMessagesDirectlyToExchange(int mode) { // arrange var routeUsingExchanges = mode > 1; var exchangeAsAddress = mode > 2; var sender = GetQueue("test.sender", removeExiting: true, oneExchangePerType: routeUsingExchanges, inputExchange: exchangeAsAddress ? "ex-test.sender" : null); var recipient = GetQueue("test.recipient", removeExiting: true, oneExchangePerType: true, inputExchange: "ex-test.recipient"); // act using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); var msg = new TransportMessageToSend { Body = Encoding.GetBytes("this is a message!") }; sender.Send("@ex-test.recipient", msg, ctx); sender.Send("@ex-test.recipient", msg, ctx); sender.Send("@ex-test.recipient", msg, ctx); tx.Complete(); } // assert var receivedTransportMessages = GetAllMessages(recipient); receivedTransportMessages.Count.ShouldBe(3); }
public void CanSendMessagesInTransactionToMultipleQueues(bool commitTransactionAndExpectMessagesToBeThere) { // arrange var sender = GetQueue("test.tx.sender"); var firstRecipient = GetQueue("test.tx.recipient1"); var secondRecipient = GetQueue("test.tx.recipient2"); // act using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); var msg = new TransportMessageToSend { Body = Encoding.GetBytes("this is a message!") }; sender.Send(firstRecipient.InputQueue, msg, ctx); sender.Send(firstRecipient.InputQueue, msg, ctx); sender.Send(firstRecipient.InputQueue, msg, ctx); sender.Send(secondRecipient.InputQueue, msg, ctx); sender.Send(secondRecipient.InputQueue, msg, ctx); sender.Send(secondRecipient.InputQueue, msg, ctx); if (commitTransactionAndExpectMessagesToBeThere) tx.Complete(); } // assert var receivedTransportMessagesFromFirstRecipient = GetAllMessages(firstRecipient); var receivedTransportMessagesFromSecondRecipient = GetAllMessages(secondRecipient); receivedTransportMessagesFromFirstRecipient.Count.ShouldBe(commitTransactionAndExpectMessagesToBeThere ? 3 : 0); receivedTransportMessagesFromSecondRecipient.Count.ShouldBe(commitTransactionAndExpectMessagesToBeThere ? 3 : 0); }
public void CanSendAndReceiveMessages(int count, int consumers) { const string senderInputQueue = "test.rabbit.sender"; const string receiverInputQueue = "test.rabbit.receiver"; var sender = GetQueue(senderInputQueue); var receiver = GetQueue(receiverInputQueue); var totalMessageCount = count * consumers; var stopwatch = Stopwatch.StartNew(); Console.WriteLine("Sending {0} messages", totalMessageCount); Enumerable.Range(0, totalMessageCount).ToList() .ForEach( i => sender.Send(receiverInputQueue, new TransportMessageToSend { Body = Encoding.UTF7.GetBytes("w00t! message " + i) }, new NoTransaction())); var totalSeconds = stopwatch.Elapsed.TotalSeconds; Console.WriteLine("Sending {0} messages took {1:0.0} s - that's {2:0} msg/s", totalMessageCount, totalSeconds, totalMessageCount / totalSeconds); Thread.Sleep(1.Seconds()); Console.WriteLine("Receiving {0} messages", totalMessageCount); long receivedMessageCount = 0; stopwatch = Stopwatch.StartNew(); var threads = Enumerable.Range(0, consumers) .Select(i => new Thread(_ => { var gotNoMessageCount = 0; do { using (var scope = new TransactionScope()) { var ctx = new AmbientTransactionContext(); var receivedTransportMessage = receiver.ReceiveMessage(ctx); if (receivedTransportMessage == null) { gotNoMessageCount++; continue; } Encoding.UTF7.GetString(receivedTransportMessage.Body).ShouldStartWith("w00t! message "); Interlocked.Increment(ref receivedMessageCount); scope.Complete(); } } while (gotNoMessageCount < 3); })) .ToList(); threads.ForEach(t => t.Start()); threads.ForEach(t => t.Join()); totalSeconds = stopwatch.Elapsed.TotalSeconds; Console.WriteLine("Receiving {0} messages spread across {1} consumers took {2:0.0} s - that's {3:0} msg/s", totalMessageCount, consumers, totalSeconds, totalMessageCount / totalSeconds); receivedMessageCount.ShouldBe(totalMessageCount); }
void DoWork() { while (keepWorking) { try { using (var tx = new TransactionScope()) { var transactionContext = new AmbientTransactionContext(); var message = queue.ReceiveMessage(transactionContext); if (message == null) { Thread.Sleep(200); continue; } var destinationForThisMessage = getNextDestination(); log.Debug("Received message {0} will be forwarded to {1}", message.Id, destinationForThisMessage); queue.Send(destinationForThisMessage, message.ToForwardableMessage(), transactionContext); tx.Complete(); } } catch (Exception exception) { log.Error("An error occurred while trying to process a message: {0}", exception); } } }
public void MultipleSendOperationsToMultipleQueuesAreEnlistedInTheSameTransaction(bool commitTransactionAndExpectMessagesToBeThere) { // arrange const string queueName1 = "test.tx.queue1"; const string queueName2 = "test.tx.queue2"; var recipient1 = NewRawMsmqQueue(queueName1); var recipient2 = NewRawMsmqQueue(queueName2); disposables.Add(recipient1); disposables.Add(recipient2); var encoding = Encoding.UTF8; using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); // act senderQueue.Send(queueName1, new TransportMessageToSend { Body = encoding.GetBytes("yo dawg 1!") }, ctx); senderQueue.Send(queueName1, new TransportMessageToSend { Body = encoding.GetBytes("yo dawg 2!") }, ctx); senderQueue.Send(queueName2, new TransportMessageToSend { Body = encoding.GetBytes("yo dawg 3!") }, ctx); senderQueue.Send(queueName2, new TransportMessageToSend { Body = encoding.GetBytes("yo dawg 4!") }, ctx); if (commitTransactionAndExpectMessagesToBeThere) tx.Complete(); } // assert var allMessages = GetAllMessages(recipient1).Concat(GetAllMessages(recipient2)).ToList(); if (commitTransactionAndExpectMessagesToBeThere) { allMessages.Count.ShouldBe(4); var receivedMessages = allMessages.Select(m => encoding.GetString(m.Body)).ToList(); receivedMessages.ShouldContain("yo dawg 1!"); receivedMessages.ShouldContain("yo dawg 2!"); receivedMessages.ShouldContain("yo dawg 3!"); receivedMessages.ShouldContain("yo dawg 4!"); } else { allMessages.Count.ShouldBe(0); } }
public void MessageIsSentWhenAmbientTransactionIsCommitted() { using (var tx = new TransactionScope()) { var ctx = new AmbientTransactionContext(); senderQueue.Send(destinationQueueName, serializer.Serialize(new Message { Messages = new object[] { "W00t!" }, }), ctx); tx.Complete(); } var msmqMessage = Receive(); Assert.IsNotNull(msmqMessage, "No message was received within timeout!"); var transportMessage = (ReceivedTransportMessage)msmqMessage.Body; var message = serializer.Deserialize(transportMessage); message.Messages[0].ShouldBe("W00t!"); }
public void MessageIsNotSentWhenAmbientTransactionIsNotCommitted() { using (new TransactionScope()) { var ctx = new AmbientTransactionContext(); senderQueue.Send(destinationQueueName, serializer.Serialize(new Message { Messages = new object[] { "W00t! should not be delivered!" } }), ctx); //< we exit the scope without completing it! } var transportMessage = Receive(); if (transportMessage != null) { Assert.Fail("No messages should have been received! ARGGH: {0}", transportMessage.Body); } }