public void YeahItDoes()
{
var deliveryAttempts = 0;
adapter.Handle<string>(str =>
{
Interlocked.Increment(ref deliveryAttempts);
throw new ApplicationException(RecognizableErrorMessage);
});
adapter.Bus.SendLocal("HELLO MY FRIEND!!!!!2222");
var timeout = 5.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Did not receive PoisonMessage event within {0} timeout", timeout);
Assert.That(deliveryAttempts, Is.EqualTo(5), "Expected 5 failed delivery attempts to have been made");
// be sure that message has moved and everything
Thread.Sleep(1.Seconds());
using (var errorQueueClient = new AzureServiceBusMessageQueue(ConnectionString, ErrorQueueName))
{
var receivedTransportMessage = errorQueueClient.ReceiveMessage(new NoTransaction());
Assert.That(receivedTransportMessage, Is.Not.Null);
}
}
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);
}
protected override void DoSetUp()
{
events = new ConcurrentQueue<string>();
builtinContainerAdapter = new BuiltinContainerAdapter();
TrackDisposable(builtinContainerAdapter);
using (var q = new AzureServiceBusMessageQueue(AzureServiceBusMessageQueueFactory.ConnectionString, QueueName))
{
q.Purge();
}
Configure.With(builtinContainerAdapter)
.Logging(l => l.Console(minLevel: LogLevel.Info))
.Transport(t => t.UseAzureServiceBus(AzureServiceBusMessageQueueFactory.ConnectionString, QueueName, "error"))
.Events(e =>
{
e.MessageContextEstablished += (bus, context) =>
{
WriteEvent("msg context established");
context.Disposed += () =>
{
WriteEvent("msg context disposed");
};
};
e.AddUnitOfWorkManager(new EventOutputtingUnitOfWorkManager(text => WriteEvent(text)));
})
.CreateBus().Start(1);
}
static void Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName,
string errorQueueName)
{
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName, errorQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
}
static void Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName,
string errorQueueName)
{
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
}
static IAsbOptions Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName, string errorQueueName)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString", "You need to specify a connection string in order to configure Rebus to use Azure Service Bus as the transport. If you want to simulate Azure Service Bus by using MSMQ, you may use 'UseDevelopmentStorage=true' as the connection string.");
}
if (ShouldEmulateAzureEnvironment(connectionString))
{
log.Info("Azure Service Bus configuration has detected that development storage should be used - for the");
configurer.UseMsmq(inputQueueName, errorQueueName);
// when we're emulating with MSMQ, we make this noop action available to allow user code to pretend to renew the peek lock
configurer
.Backbone
.ConfigureEvents(e =>
{
e.MessageContextEstablished += (bus, context) =>
{
var noop = (Action)(() => log.Info("Azure Service Bus message peek lock would be renewed at this time"));
context.Items[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction] = noop;
};
});
return(new NoopAsbOptions());
}
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
azureServiceBusMessageQueue.EnsureQueueExists(errorQueueName);
// transfer renew-peek-lock-action from transaction context to message context
configurer
.Backbone
.ConfigureEvents(e =>
{
e.MessageContextEstablished += (bus, context) =>
{
var renewAction = TransactionContext.Current[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction];
context.Items[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction] = renewAction;
};
});
return(new AsbOptions(azureServiceBusMessageQueue));
}
void InitializeBus(int numberOfRetries, BuiltinContainerAdapter adapter, ManualResetEvent poisonEventToSet)
{
RebusLoggerFactory.Current = new ConsoleLoggerFactory(false) { MinLevel = LogLevel.Warn };
var connectionString = AzureServiceBusMessageQueueFactory.ConnectionString;
using (var queue = new AzureServiceBusMessageQueue(connectionString, "test_input"))
{
queue.Purge();
}
Configure.With(adapter)
.Transport(t => t.UseAzureServiceBus(connectionString, "test_input", "error"))
.Behavior(b => b.SetMaxRetriesFor<FacilityException>(numberOfRetries))
.Events(e => e.PoisonMessage += (bus, message, info) => poisonEventToSet.Set())
.CreateBus()
.Start(1);
}
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);
}
static void Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName,
string errorQueueName)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString", "You need to specify a connection string in order to configure Rebus to use Azure Service Bus as the transport. If you want to simulate Azure Service Bus by using MSMQ, you may use 'UseDevelopmentStorage=true' as the connection string.");
}
if (ShouldEmulateAzureEnvironment(connectionString))
{
log.Info("Azure Service Bus configuration has detected that development storage should be used - for the");
configurer.UseMsmq(inputQueueName, errorQueueName);
return;
}
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
azureServiceBusMessageQueue.GetOrCreateSubscription(errorQueueName);
}
protected override void DoSetUp()
{
events = new ConcurrentQueue<string>();
adapter = new BuiltinContainerAdapter();
TrackDisposable(adapter);
using (var queue = new AzureServiceBusMessageQueue(connectionString, QueueName))
{
queue.Delete();
}
AzureServiceBusMessageQueue.PeekLockDurationOnQueueInitialization = TimeSpan.FromMinutes(1);
Configure.With(adapter)
.Logging(l => l.Console(minLevel: LogLevel.Info))
.Transport(t => t.UseAzureServiceBus(connectionString, QueueName, "error")
.AutomaticallyRenewPeekLockEvery(TimeSpan.FromMinutes(0.8)))
.CreateBus()
.Start();
}
static List<ReceivedTransportMessage> GetAllTheMessages(AzureServiceBusMessageQueue azureServiceBusMessageQueue, ITransactionContext transactionContext)
{
var messages = new List<ReceivedTransportMessage>();
ReceivedTransportMessage transportMessage;
while ((transportMessage = azureServiceBusMessageQueue.ReceiveMessage(transactionContext)) != null)
{
messages.Add(transportMessage);
}
return messages;
}
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");
}
}
static void Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName,
string errorQueueName)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString", "You need to specify a connection string in order to configure Rebus to use Azure Service Bus as the transport. If you want to simulate Azure Service Bus by using MSMQ, you may use 'UseDevelopmentStorage=true' as the connection string.");
}
if (ShouldEmulateAzureEnvironment(connectionString))
{
log.Info("Azure Service Bus configuration has detected that development storage should be used - for the");
configurer.UseMsmq(inputQueueName, errorQueueName);
return;
}
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
azureServiceBusMessageQueue.GetOrCreateSubscription(errorQueueName);
}
public AsbOptions(AzureServiceBusMessageQueue queue)
{
this.queue = queue;
}
public AsbOptions(AzureServiceBusMessageQueue queue)
{
this.queue = queue;
}
static IAsbOptions Configure(RebusTransportConfigurer configurer, string connectionString, string inputQueueName, string errorQueueName)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString", "You need to specify a connection string in order to configure Rebus to use Azure Service Bus as the transport. If you want to simulate Azure Service Bus by using MSMQ, you may use 'UseDevelopmentStorage=true' as the connection string.");
}
if (ShouldEmulateAzureEnvironment(connectionString))
{
log.Info("Azure Service Bus configuration has detected that development storage should be used - for the");
configurer.UseMsmq(inputQueueName, errorQueueName);
// when we're emulating with MSMQ, we make this noop action available to allow user code to pretend to renew the peek lock
configurer
.Backbone
.ConfigureEvents(e =>
{
e.MessageContextEstablished += (bus, context) =>
{
var noop = (Action)(() => log.Info("Azure Service Bus message peek lock would be renewed at this time"));
context.Items[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction] = noop;
};
});
return new NoopAsbOptions();
}
var azureServiceBusMessageQueue = new AzureServiceBusMessageQueue(connectionString, inputQueueName);
configurer.UseSender(azureServiceBusMessageQueue);
configurer.UseReceiver(azureServiceBusMessageQueue);
configurer.UseErrorTracker(new ErrorTracker(errorQueueName));
azureServiceBusMessageQueue.EnsureQueueExists(errorQueueName);
// transfer renew-peek-lock-action from transaction context to message context
configurer
.Backbone
.ConfigureEvents(e =>
{
e.MessageContextEstablished += (bus, context) =>
{
var renewAction = TransactionContext.Current[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction];
context.Items[AzureServiceBusMessageQueue.AzureServiceBusRenewLeaseAction] = renewAction;
};
});
return new AsbOptions(azureServiceBusMessageQueue);
}
