private void getReady()
{
theSender = JasperHost.For(_ =>
{
_.Handlers.DisableConventionalDiscovery();
_.Services.AddSingleton(theTracker);
});
var receiver = new JasperRegistry();
receiver.Handlers.DisableConventionalDiscovery();
receiver.Transports.ListenForMessagesFrom(theAddress);
receiver.Handlers.Retries.MaximumAttempts = 3;
receiver.Handlers.IncludeType <MessageConsumer>();
scheduledJobs = new FakeScheduledJobProcessor();
receiver.Services.For <IScheduledJobProcessor>().Use(scheduledJobs);
receiver.Services.For <MessageTracker>().Use(theTracker);
theReceiver = JasperHost.For(receiver);
}
public async Task <bool> SendWithReceiverDown()
{
cleanDatabase();
// Shutting it down
theReceiver.Dispose();
theReceiver = null;
var item = new ItemCreated
{
Name = "Shoe",
Id = Guid.NewGuid()
};
await send(c => c.Send(item));
var outgoing = loadAllOutgoingEnvelopes(theSender).SingleOrDefault();
StoryTellerAssert.Fail(outgoing == null, "No outgoing envelopes are persisted");
StoryTellerAssert.Fail(outgoing.MessageType != typeof(ItemCreated).ToMessageTypeName(),
$"Envelope message type expected {typeof(ItemCreated).ToMessageTypeName()}, but was {outgoing.MessageType}");
return(true);
}
public void RecycleIfNecessary()
{
if (Host.IsDisposed)
{
Host = JasperHost.Basic();
}
}
protected override void initializeStorage(IJasperHost sender, IJasperHost receiver)
{
sender.RebuildMessageStorage();
receiver.RebuildMessageStorage();
using (var conn = new SqlConnection(Servers.SqlServerConnectionString))
{
conn.Open();
conn.CreateCommand(@"
IF OBJECT_ID('receiver.item_created', 'U') IS NOT NULL
drop table receiver.item_created;
").ExecuteNonQuery();
conn.CreateCommand(@"
create table receiver.item_created
(
id uniqueidentifier not null
primary key,
name varchar(100) not null
);
").ExecuteNonQuery();
}
}
protected SagaTestHarness()
{
_host = JasperHost.For(_ =>
{
_.Handlers.DisableConventionalDiscovery().IncludeType <TSagaHandler>();
_.MartenConnectionStringIs(Servers.PostgresConnectionString);
_.Include <MartenBackedPersistence>();
_.Include <MessageTrackingExtension>();
_.Settings.ConfigureMarten(x =>
{
x.DatabaseSchemaName = "sagas";
x.AutoCreateSchemaObjects = AutoCreate.All;
}
);
_.Publish.AllMessagesTo(TransportConstants.LoopbackUri);
configure(_);
});
_history = _host.Get <MessageHistory>();
var store = _host.Get <IDocumentStore>();
store.Advanced.Clean.CompletelyRemoveAll();
}
public override void SetUp()
{
_envelopes.Clear();
_nodeLockers.Clear();
_workers = new RecordingWorkerQueue();
_schedulerAgent = new RecordingSchedulingAgent();
_host = JasperHost.For(_ =>
{
_.Settings.PersistMessagesWithSqlServer(Servers.SqlServerConnectionString);
_.Services.AddSingleton <IWorkerQueue>(_workers);
_.Services.AddSingleton <IDurabilityAgent>(_schedulerAgent);
_.Settings.Alter <JasperOptions>(x =>
{
x.Retries.FirstNodeReassignmentExecution = 30.Minutes();
x.ScheduledJobs.FirstExecution = 30.Minutes();
x.Retries.FirstNodeReassignmentExecution = 30.Minutes();
x.Retries.NodeReassignmentPollingTime = 30.Minutes();
});
});
_host.Get <IEnvelopePersistence>().Admin.ClearAllPersistedEnvelopes();
_serializers = _host.Get <MessagingSerializationGraph>();
_host.RebuildMessageStorage();
_currentNodeId = _host.Get <JasperOptions>().UniqueNodeId;
_owners["This Node"] = _currentNodeId;
}
protected override ItemCreated loadItem(IJasperHost receiver, Guid id)
{
using (var session = receiver.Get <IDocumentStore>().QuerySession())
{
return(session.Load <ItemCreated>(id));
}
}
public void SendMessage([SelectionList("MessageTypes")] string messageType, string name)
{
if (!_initialized)
{
if (_publisher == null)
{
var registry = new JasperRegistry
{
ServiceName = "Publisher"
};
_publisher = _nodes.Add(registry);
}
_initialized = true;
}
var history = _nodes.History;
var type = messageTypeFor(messageType);
var message = Activator.CreateInstance(type).As <Message>();
message.Name = name;
var waiter = history.Watch(() => { _publisher.Messaging.Send(message).Wait(); });
waiter.Wait(5.Seconds());
StoryTellerAssert.Fail(!waiter.IsCompleted, "Messages were never completely tracked");
}
public override void SetUp()
{
var registry = new ScheduledMessageApp();
theReceiver = registry.Receiver;
theHost = JasperHost.For(registry);
}
public override void SetUp()
{
theTracker = new Jasper.Messaging.Tracking.MessageTracker();
var receiverPort = PortFinder.FindPort(3340);
var senderPort = PortFinder.FindPort(3370);
var publishingUri = $"tcp://localhost:{receiverPort}/durable";
var senderRegistry = new JasperRegistry();
senderRegistry.Handlers
.DisableConventionalDiscovery()
.IncludeType <CascadeReceiver>()
.IncludeType <ScheduledMessageHandler>();
senderRegistry.Services.AddSingleton(theTracker);
senderRegistry.Publish.Message <TriggerMessage>().To(publishingUri);
senderRegistry.Publish.Message <ItemCreated>().To(publishingUri);
senderRegistry.Publish.Message <Question>().To(publishingUri);
senderRegistry.Publish.Message <ScheduledMessage>().To(publishingUri);
senderRegistry.Transports.DurableListenerAt(senderPort);
configureSender(senderRegistry);
theSender = JasperHost.For(senderRegistry);
theSender.RebuildMessageStorage();
var receiverRegistry = new JasperRegistry();
receiverRegistry.Handlers.DisableConventionalDiscovery()
.IncludeType <TTriggerHandler>()
.IncludeType <TItemCreatedHandler>()
.IncludeType <QuestionHandler>()
.IncludeType <ScheduledMessageHandler>();
receiverRegistry.Transports.DurableListenerAt(receiverPort);
receiverRegistry.Handlers.Worker("items").IsDurable()
.HandlesMessage <ItemCreated>();
receiverRegistry.Services.AddSingleton(theTracker);
configureReceiver(receiverRegistry);
theReceiver = JasperHost.For(receiverRegistry);
theReceiver.RebuildMessageStorage();
initializeStorage(theSender, theReceiver);
}
public IJasperHost theHost()
{
if (_host == null)
{
_host = JasperHost.For(theRegistry);
}
return(_host);
}
public override void TearDown()
{
_host.Dispose();
_graph = null;
_chain = null;
_transport = null;
_bus = null;
_host = null;
}
protected void with(JasperRegistry registry)
{
registry.Services.Scan(_ =>
{
_.TheCallingAssembly();
_.WithDefaultConventions();
});
Host = JasperHost.For(registry);
}
public MessageHandler HandlerFor <TMessage>()
{
if (_host == null)
{
_host = JasperHost.For(theRegistry);
}
return(_host.Get <HandlerGraph>().HandlerFor(typeof(TMessage)));
}
private static void validateMessageTrackerExists(this IJasperHost runtime)
{
var history = runtime.Container.Model.For <MessageHistory>().Default;
if (history == null || history.Lifetime != ServiceLifetime.Singleton)
{
throw new InvalidOperationException(
$"The {nameof(MessageTrackingExtension)} extension is not applied to this application");
}
}
public when_bootstrapping_a_host_with_multiple_features()
{
theRegistry.Handlers.DisableConventionalDiscovery();
theRegistry.Services.AddTransient <IMainService, MainService>();
theRegistry.Services.AddTransient <IFakeStore, FakeStore>();
theHost = JasperHost.For(theRegistry);
}
private void buildRuntime()
{
theHost = JasperHost.For(_ =>
{
_.Handlers.DisableConventionalDiscovery();
_.Publish.Message <Message1>().To("stub://one");
_.Publish.Message <Message2>().To("stub://one");
_.Publish.Message <Message2>().To("stub://two");
});
}
internal void Describe(IJasperHost runtime, TextWriter writer)
{
if (runtime.HttpAddresses == null)
{
return;
}
foreach (var url in runtime.HttpAddresses)
{
writer.WriteLine($"Now listening on: {url}");
}
}
public when_shutting_down_the_host()
{
theRegistry.Handlers.DisableConventionalDiscovery();
theRegistry.Services.AddSingleton <IMainService>(mainService);
theRegistry.Services.AddTransient <IFakeStore, FakeStore>();
theHost = JasperHost.For(theRegistry);
theHost.Dispose();
}
public void ForMessage([SelectionList("MessageTypes")] string MessageType)
{
var messageType = messageTypeFor(MessageType);
if (_host == null)
{
_host = JasperHost.For(_registry);
}
var router = _host.Get <IMessageRouter>();
_tracks = router.Route(messageType);
}
/// <summary>
/// Executes an action and waits until the execution and all cascading messages
/// have completed
/// </summary>
/// <param name="runtime"></param>
/// <param name="action"></param>
/// <returns></returns>
public static async Task ExecuteAndWait(this IJasperHost runtime, Action action,
bool assertNoExceptions = false)
{
runtime.validateMessageTrackerExists();
var history = runtime.Get <MessageHistory>();
await history.Watch(action);
if (assertNoExceptions)
{
history.AssertNoExceptions();
}
}
/// <summary>
/// Invoke a message through IServiceBus.Invoke(msg) and wait until all processing
/// of the original message and cascading messages are complete
/// </summary>
/// <param name="runtime"></param>
/// <param name="action"></param>
/// <returns></returns>
public static async Task ExecuteAndWait(this IJasperHost runtime, Func <Task> action,
int timeoutInMilliseconds = 5000, bool assertNoExceptions = false)
{
runtime.validateMessageTrackerExists();
var history = runtime.Get <MessageHistory>();
await history.WatchAsync(action, timeoutInMilliseconds);
if (assertNoExceptions)
{
history.AssertNoExceptions();
}
}
/// <summary>
/// Send a message through the service bus and wait until that message
/// and all cascading messages have been successfully processed
/// </summary>
/// <param name="runtime"></param>
/// <param name="message"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static async Task SendMessageAndWait <T>(this IJasperHost runtime, T message,
int timeoutInMilliseconds = 5000, bool assertNoExceptions = false)
{
runtime.validateMessageTrackerExists();
var history = runtime.Get <MessageHistory>();
await history.WatchAsync(() => runtime.Messaging.Send(message), timeoutInMilliseconds);
if (assertNoExceptions)
{
history.AssertNoExceptions();
}
}
protected override async Task withContext(IJasperHost sender, IMessageContext context,
Func <IMessageContext, Task> action)
{
var senderStore = sender.Get <IDocumentStore>();
using (var session = senderStore.LightweightSession())
{
await context.EnlistInTransaction(session);
await action(context);
await session.SaveChangesAsync();
}
}
/// <summary>
/// Executes an action and waits until the execution and all cascading messages
/// have completed
/// </summary>
/// <param name="runtime"></param>
/// <param name="action"></param>
/// <returns></returns>
public static async Task ExecuteAndWait(this IJasperHost runtime, Func <IMessageContext, Task> action,
bool assertNoExceptions = false)
{
runtime.validateMessageTrackerExists();
var history = runtime.Get <MessageHistory>();
var context = runtime.Get <IMessageContext>();
await history.WatchAsync(() => action(context));
if (assertNoExceptions)
{
history.AssertNoExceptions();
}
}
protected void withApplication()
{
_host = JasperHost.For(_ =>
{
_.Handlers.DisableConventionalDiscovery().IncludeType <TSagaHandler>();
_.Include <MessageTrackingExtension>();
_.Publish.AllMessagesTo(TransportConstants.LoopbackUri);
configure(_);
});
_history = _host.Get <MessageHistory>();
}
public async Task send_green_that_gets_received_as_blue()
{
greenApp = JasperHost.For <GreenApp>();
blueApp = JasperHost.For(new BlueApp(theTracker));
var waiter = theTracker.WaitFor <BlueMessage>();
await greenApp.Messaging.Send(new GreenMessage { Name = "Kareem Abdul Jabbar" });
var envelope = await waiter;
envelope.Message
.ShouldBeOfType <BlueMessage>()
.Name.ShouldBe("Kareem Abdul Jabbar");
}
public IGrammar IfTheApplicationIs()
{
return(Embed <ServiceBusApplication>("If a service bus application is configured to")
.After(c =>
{
_host = c.State.Retrieve <IJasperHost>();
try
{
_host.Get <IEnvelopePersistence>().Admin.ClearAllPersistedEnvelopes();
}
catch (Exception)
{
// too flaky in windows, and this is only for testing
}
}));
}
protected override void initializeStorage(IJasperHost theSender, IJasperHost theReceiver)
{
theSender.RebuildMessageStorage();
theReceiver.RebuildMessageStorage();
using (var conn = new NpgsqlConnection(Servers.PostgresConnectionString))
{
conn.Open();
conn.CreateCommand(@"
create table if not exists receiver.item_created
(
id uuid not null primary key,
name varchar(100) not null
)
").ExecuteNonQuery();
}
}
public override void SetUp()
{
_envelopes.Clear();
_nodeLockers.Clear();
_workers = new RecordingWorkerQueue();
_host = JasperHost.CreateDefaultBuilder()
.UseJasper(_ =>
{
_.ServiceName = Guid.NewGuid().ToString();
_.MartenConnectionStringIs(Servers.PostgresConnectionString);
_.Services.AddSingleton <IWorkerQueue>(_workers);
_.Include <MartenBackedPersistence>();
_.Settings.Alter <JasperOptions>(x =>
{
x.Retries.FirstNodeReassignmentExecution = 30.Minutes();
x.ScheduledJobs.FirstExecution = 30.Minutes();
x.Retries.FirstNodeReassignmentExecution = 30.Minutes();
x.Retries.NodeReassignmentPollingTime = 30.Minutes();
});
})
.StartJasper();
_admin = _host.Get <IEnvelopePersistence>().Admin;
_admin.RebuildSchemaObjects();
_settings = _host.Get <PostgresqlSettings>();
_serializers = _host.Get <MessagingSerializationGraph>();
theStore = _host.Get <IDocumentStore>();
theStore.Advanced.Clean.DeleteAllDocuments();
_currentNodeId = _host.Get <JasperOptions>().UniqueNodeId;
_owners["This Node"] = _currentNodeId;
}
