private void getReady()
{
theSender = JasperHost.For(_ =>
{
_.Handlers.DisableConventionalDiscovery();
_.Extensions.UseMessageTrackingTestingSupport();
});
var receiver = new JasperOptions();
receiver.Handlers.DisableConventionalDiscovery();
receiver.Endpoints.ListenForMessagesFrom(theAddress);
receiver.Handlers.Retries.MaximumAttempts = 3;
receiver.Handlers.IncludeType <MessageConsumer>();
scheduledJobs = new FakeScheduledJobProcessor();
receiver.Services.For <IScheduledJobProcessor>().Use(scheduledJobs);
receiver.Extensions.UseMessageTrackingTestingSupport();
theReceiver = JasperHost.For(receiver);
}
internal async Task <HandlerCall[]> FindCalls(JasperOptions options)
{
if (_conventionalDiscoveryDisabled)
{
return(_explicitTypes.SelectMany(actionsFromType).ToArray());
}
if (options.ApplicationAssembly == null)
{
return(new HandlerCall[0]);
}
_assemblies.Add(options.ApplicationAssembly);
var types = await TypeRepository.FindTypes(_assemblies,
TypeClassification.Concretes | TypeClassification.Closed, type => _typeFilters.Matches(type))
.ConfigureAwait(false);
return(types
.Where(x => !x.HasAttribute <JasperIgnoreAttribute>())
.Concat(_explicitTypes)
.Distinct()
.SelectMany(actionsFromType).ToArray());
}
public void Configure(JasperOptions options)
{
// this will force the transport collection
// to add Rabbit MQ if it does not alreay
// exist
options.Endpoints.RabbitMqTransport();
}
public override void SetUp()
{
_tracker = new AttemptTracker();
var options = new JasperOptions();
options.Extensions.UseMessageTrackingTestingSupport();
options.Endpoints.As <TransportCollection>().Add(new StubTransport());
options.Services.AddSingleton(_tracker);
options.Endpoints.Publish(x => x.Message <ErrorCausingMessage>()
.To("local://1".ToUri()));
_host = JasperHost.For(options);
_transport = _host.GetStubTransport();
_graph = _host.Get <HandlerGraph>();
_chain = _graph.ChainFor <ErrorCausingMessage>();
_bus = _host.Get <IMessageContext>();
}
public void Configure(JasperOptions options)
{
var frameProvider = new EFCorePersistenceFrameProvider();
options.Advanced.CodeGeneration.SetSagaPersistence(frameProvider);
options.Advanced.CodeGeneration.SetTransactions(frameProvider);
}
public MessagingRoot(MessagingSerializationGraph serialization,
JasperOptions settings,
HandlerGraph handlers,
IDurableMessagingFactory factory,
ISubscriberGraph subscribers,
IMessageLogger messageLogger,
IContainer container,
ITransportLogger transportLogger)
{
Settings = settings;
_handlers = handlers;
_transportLogger = transportLogger;
Factory = factory;
Subscribers = subscribers;
Transports = container.QuickBuildAll <ITransport>().ToArray();
Serialization = serialization;
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Logger,
container.QuickBuildAll <IMissingHandler>(),
this);
Workers = new WorkerQueue(Logger, Pipeline, settings);
Router = new MessageRouter(this, handlers);
// TODO -- ZOMG this is horrible, and I admit it.
if (Factory is NulloDurableMessagingFactory f)
{
f.ScheduledJobs = ScheduledJobs;
}
}
public MartenBackedListenerContext()
{
theStore = DocumentStore.For(_ =>
{
_.Connection(Servers.PostgresConnectionString);
_.PLV8Enabled = false;
_.Storage.Add <PostgresqlEnvelopeStorage>();
});
theStore.Advanced.Clean.CompletelyRemoveAll();
theStore.Schema.ApplyAllConfiguredChangesToDatabase();
theWorkerQueue = Substitute.For <IWorkerQueue>();
theSettings = new JasperOptions();
var tables = new EnvelopeTables(theSettings, new StoreOptions());
var retries = new EnvelopeRetries(new MartenEnvelopePersistor(theStore, tables), TransportLogger.Empty(),
theSettings);
theListener = new DurableListener(
Substitute.For <IListeningAgent>(),
theWorkerQueue,
TransportLogger.Empty(), theSettings, retries, new MartenEnvelopePersistor(theStore, tables));
}
public ReassignFromDormantNodes(EnvelopeTables marker, JasperOptions settings)
{
_marker = marker;
_reassignDormantNodeIncomingSql = $@"
update {marker.Incoming}
set owner_id = 0
where
owner_id in (
select distinct owner_id from {marker.Incoming}
where owner_id != 0 AND owner_id != {settings.UniqueNodeId} AND pg_try_advisory_xact_lock(owner_id)
);
";
_reassignDormantNodeOutgoingSql = $@"
update {marker.Outgoing}
set owner_id = 0
where
owner_id in (
select distinct owner_id from {marker.Outgoing}
where owner_id != 0 AND owner_id != {settings.UniqueNodeId} AND pg_try_advisory_xact_lock(owner_id)
);
";
}
public ApplicationInsightsMetrics(TelemetryClient client, JasperOptions settings)
{
_client = client;
_settings = settings;
_client.Context.Properties.Add("Node", settings.NodeId);
}
public void Start(IMessagingRoot root)
{
var settings = root.Options;
_settings = settings;
_logger = root.Logger;
_root = root;
organizeTransports(settings, root.Transports);
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
foreach (var transport in root.Transports)
{
transport.StartListening(root);
}
buildInitialSendingAgents(root);
GetOrBuild(TransportConstants.RetryUri);
}
public MessagingRoot(MessagingSerializationGraph serialization,
JasperOptions options,
HandlerGraph handlers,
ISubscriberGraph subscribers,
IMessageLogger messageLogger,
IContainer container,
ITransportLogger transportLogger
)
{
Options = options;
Handlers = handlers;
_transportLogger = transportLogger;
Subscribers = subscribers;
Transports = container.QuickBuildAll <ITransport>().ToArray();
Serialization = serialization;
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Logger,
container.QuickBuildAll <IMissingHandler>(),
this);
Workers = new WorkerQueue(Logger, Pipeline, options);
Router = new MessageRouter(this, handlers);
_persistence = new Lazy <IEnvelopePersistence>(() => container.GetInstance <IEnvelopePersistence>());
}
public async Task enqueue_locally()
{
var registry = new JasperOptions();
registry.Handlers.DisableConventionalDiscovery();
registry.Services.Scan(x =>
{
x.TheCallingAssembly();
x.WithDefaultConventions();
});
registry.Handlers.IncludeType <MessageConsumer>();
registry.Services.ForSingletonOf <IFakeStore>().Use <FakeStore>();
registry.Extensions.UseMessageTrackingTestingSupport();
using (var host = JasperHost.For(registry))
{
var message = new Message1
{
Id = Guid.NewGuid()
};
var session = await host.ExecuteAndWait(c => c.Enqueue(message));
var tracked = session.FindSingleTrackedMessageOfType <Message1>();
tracked.Id.ShouldBe(message.Id);
}
}
protected override IListeningAgent buildListeningAgent(Uri uri, JasperOptions settings)
{
var agent = _settings.For(uri);
agent.Start();
return(agent.CreateListeningAgent(uri, settings, logger));
}
public MessagingRoot(MessagingSerializationGraph serialization,
JasperOptions options,
IMessageLogger messageLogger,
IContainer container,
ITransportLogger transportLogger
)
{
Options = options;
Handlers = options.HandlerGraph;
TransportLogger = transportLogger;
Settings = options.Advanced;
Serialization = serialization;
MessageLogger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, Handlers, MessageLogger,
container.QuickBuildAll <IMissingHandler>(),
this);
Runtime = new TransportRuntime(this);
_persistence = new Lazy <IEnvelopePersistence>(() => container.GetInstance <IEnvelopePersistence>());
Router = new EnvelopeRouter(this);
_container = container;
Cancellation = Settings.Cancellation;
}
public async Task SendMessage([SelectionList("MessageTypes")] string messageType, string name)
{
if (!_initialized)
{
if (_publisher == null)
{
var registry = new JasperOptions
{
ServiceName = "Publisher"
};
registry.Extensions.UseMessageTrackingTestingSupport();
_publisher = _nodes.Add(registry);
}
_initialized = true;
}
var type = messageTypeFor(messageType);
var message = Activator.CreateInstance(type).As <Message>();
message.Name = name;
await _publisher.SendMessageAndWait(message);
}
public TransportBase(string protocol, ITransportLogger logger,
JasperOptions options)
{
this.logger = logger;
JasperOptions = options;
Protocol = protocol;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, JasperOptions messaging)
{
// This is optional, but it's awfully helpful
// to configure the message bus part of Jasper directly
// from configuration
messaging.ListenForMessagesFrom(Configuration["ListeningEndpoint"]);
messaging.AddSubscription(Subscription.All(Configuration["OtherServiceUri"]));
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
// The ordering here is meaningful, but we think that
// Jasper's routing is more efficient, so let it try
// first
app.UseJasper();
app.UseMvc();
}
public static JasperStorytellerHost <JasperOptions> Basic(Action <JasperOptions> configure = null)
{
var jasperRegistry = new JasperOptions();
configure?.Invoke(jasperRegistry);
return(new JasperStorytellerHost <JasperOptions>(jasperRegistry));
}
public RecoverIncomingMessages(IEnvelopePersistence persistence, IWorkerQueue workers, JasperOptions options,
ITransportLogger logger)
{
_persistence = persistence;
_workers = workers;
_options = options;
_logger = logger;
}
public static JasperStorytellerHost <JasperOptions> Basic(Action <JasperOptions> configure = null)
{
var JasperOptions = new JasperOptions();
configure?.Invoke(JasperOptions);
return(new JasperStorytellerHost <JasperOptions>(JasperOptions));
}
public TransportBase(string protocol, IDurableMessagingFactory factory, ITransportLogger logger,
JasperOptions settings)
{
_durableMessagingFactory = factory;
this.logger = logger;
JasperOptions = settings;
Protocol = protocol;
}
protected override void configureSender(JasperOptions senderOptions)
{
senderOptions.UseMarten(marten =>
{
marten.Connection(Servers.PostgresConnectionString);
marten.DatabaseSchemaName = "outbox_sender";
});
}
protected override void configureReceiver(JasperOptions receiverOptions)
{
receiverOptions.Extensions.UseMarten(marten =>
{
marten.Connection(Servers.PostgresConnectionString);
marten.DatabaseSchemaName = "outbox_receiver";
});
}
public override void SetUp()
{
var receiverPort = PortFinder.FindPort(3340);
var senderPort = PortFinder.FindPort(3370);
var publishingUri = $"tcp://localhost:{receiverPort}/durable";
var senderRegistry = new JasperOptions();
senderRegistry.Handlers
.DisableConventionalDiscovery()
.IncludeType <CascadeReceiver>()
.IncludeType <ScheduledMessageHandler>();
senderRegistry.Extensions.UseMessageTrackingTestingSupport();
senderRegistry.Endpoints.Publish(x =>
{
x.Message <TriggerMessage>();
x.Message <ItemCreated>();
x.Message <Question>();
x.Message <ScheduledMessage>();
x.ToPort(receiverPort).Durably();
});
senderRegistry.Endpoints.ListenAtPort(senderPort).Durable();
configureSender(senderRegistry);
theSender = JasperHost.For(senderRegistry);
theSender.RebuildMessageStorage();
var receiverRegistry = new JasperOptions();
receiverRegistry.Extensions.UseMessageTrackingTestingSupport();
receiverRegistry.Handlers.DisableConventionalDiscovery()
.IncludeType <TTriggerHandler>()
.IncludeType <TItemCreatedHandler>()
.IncludeType <QuestionHandler>()
.IncludeType <ScheduledMessageHandler>();
receiverRegistry.Endpoints.ListenAtPort(receiverPort).Durable();
receiverRegistry.Extensions.UseMessageTrackingTestingSupport();
configureReceiver(receiverRegistry);
theReceiver = JasperHost.For(receiverRegistry);
theReceiver.RebuildMessageStorage();
initializeStorage(theSender, theReceiver);
}
public DurableListener(IListeningAgent agent, IWorkerQueue queues, ITransportLogger logger,
JasperOptions options, IEnvelopePersistence persistence)
{
_agent = agent;
_queues = queues;
_logger = logger;
_options = options;
_persistence = persistence;
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IConfiguration configuration,
JasperOptions jasper)
{
jasper.ServiceName = configuration["name"];
var listener = $"{env.EnvironmentName}Listener";
jasper.ListenForMessagesFrom(configuration[listener]);
}
public MessageRouter(IMessagingRoot root, HandlerGraph handlers)
{
_serializers = root.Serialization;
_subscribers = root.Subscribers;
_handlers = handlers;
_logger = root.Logger;
_settings = root.Options;
_workers = _handlers.Workers;
}
public MetricsCollector(IMetrics metrics, IEnvelopePersistor persistor, IMessageLogger logger,
JasperOptions settings, IWorkerQueue workers)
{
_metrics = metrics;
_persistor = persistor;
_logger = logger;
_settings = settings;
_workers = workers;
}
protected void with(Action <JasperOptions> configuration)
{
var registry = new JasperOptions();
configuration(registry);
with(registry);
}
private void assertNoUnknownTransportsInSubscribers(JasperOptions settings)
{
var unknowns = settings.Subscriptions.Where(x => !ValidTransports.Contains(x.Uri.Scheme)).ToArray();
if (unknowns.Length > 0)
{
throw new UnknownTransportException(
$"Unknown transports referenced in {unknowns.Select(x => x.Uri.ToString()).Join(", ")}");
}
}
